陣列是具有相同資料型別的一組資料集合，基本在每一門編程語言中都有它的影子，我們今天來看一下JAVA里面的陣列，
目錄
- 一維陣列
- 二維陣列
- 遍歷陣列
- 替換元素
- 陣列排序
- 陣列拷貝
- 元素查詢
- 排序演算法
一維陣列
創建方法
陣列元素型別 陣列名字[];
陣列元素型別[] 陣列名字;
比如：
int array[];//int 型別陣列
String str[];//String型別陣列
我們還要給陣列申請空間：
陣列名字 = new 陣列元素的型別[陣列元素的個數];
array = new int[10];//代表創建了一個有10個元素的整型陣列
//注意，當我們用new關鍵字為陣列分配記憶體的時候，整型陣列中各個元素初始值都為0
綜合上面兩種方法，我們可以直接在宣告陣列的時候為其開辟記憶體空間：
陣列元素的型別 陣列名 = new 陣列元素的型別[陣列元素的個數];
int array[] = new int[10]
初始化陣列（一維陣列）
常見的初始化方法如下：
int array[] = new int[]{1,2,3,4,5};
或者
int shuzu[] = {1,2,3,4,5};
看一個栗子：
public class Day {
public static void main(String[] args) {
int array[] = new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
int i;
for(i = 0;i<12;i++){
System.out.println((i+1)+"月"+array[i]+"天");
}
}
}
//我們創建陣列array來承接天數，然后回圈將其輸出，
二維陣列
二維陣列一般表示行列間的關系，也是要重點掌握的，
創建方法
陣列元素的型別 陣列名字[][];
陣列元素的型別[][] 陣列名字;
代碼如下：
int array[][];
我們可以直接分配記憶體空間:
array = new int[2][5];
或者
也可以分別為每一維分配記憶體空間：
array = new int[2][];
array[0] = new int[2];
array[1] = new int[3];
兩種方法均可
初始化二維陣列
type arrayname[][] = {value1,value2,value3....};
/*
type 是指陣列資料的型別
arrayname 是指陣列的名稱
value 是指陣列中各元素的值
*/
我們看一個代碼：
int array[][] = {{2,5},{5,1}};
我們應當注意初始化我們的二維陣列后，應當注意陣列的小標是在0開始的，
對于陣列賦值，我們也可以直接進行賦值：
array[1][1] = 20;
我們寫一個類Matrix，在主方法中撰寫代碼實作輸出一個3行4列且所有元素均為0的矩陣：
public class Matrix {
public static void main(String[] args) {
int array[][] = new int[3][4];
for(int i=0; i<array.length;i++){
for(int j=0; j<array[i].length;j++){
System.out.println(array[i][j]);
}
System.out.println();
}
}
}
和一維陣列一樣，創建成功后，系統會給每一個元素分配初始值 0，
遍歷陣列
我們一般使用for回圈來實作遍歷陣列，我們重點看一下如何遍歷二維陣列，我們需要雙重for回圈，
舉個簡單例子：
public class Matrix {
public static void main(String[] args) {
int array[][] = new int[3][4];
for(int i=0; i<array.length;i++){
for(int j=0; j<array[i].length;j++){
System.out.println(array[i][j]);
}
System.out.println();
}
}
}
但是一般在JAVA里面，我們不會這么玩，我們使用 foreach 來實作陣列遍歷：
public class Find {
public static void main(String[] args) {
int array[][] = {{4,3},{5,3}};
int i = 0;
for(int a[]: array){
i++;
int j=0;
for(int b: a){
j++;
if(i==array.length && j==a.length){
System.out.println(b);
}else{
System.out.println(b + ",");
}
}
}
}
}
替換元素
有時我們會遇到讓我們替換陣列里一些元素的情況，我們使用fill方法來實作：
fill(int[] array,int value);
使用指定的int值分配給int型陣列的每個元素
我們來看一個簡單的栗子：
import java.util.Arrays;
public class Swap{
public static void main(String[] args) {
int array[] = new int[5];
Arrays.fill(array,6);
for(int i = 0;i<array.length;i++){
System.out.println("第"+i+"個元素是:"+array[i]);
}
}
}
上面的栗子，使得我們陣列里面的每一個元素賦值均為6；
但是我們一般想要的是指定一些位置，那么我們繼續來看：
fill(int[] array,int fromIndex,int toIndex,int value);
fromIndex 是要使用指定值填充的第一個元素的索引（被包括）
toIndex 是使用指定值填充的最后一個元素的索引（不包括）
value 是儲存在陣列所有元素中的值
//我們應當注意不要讓索引位置越界，否則會出現陣列越界例外
import java.util.Arrays;
public class Fill{
public static void main(String[] args) {
int array[] = new int[]{1,2,3,4};
Arrays.fill(array,1,2,6);//替換陣列里第二個元素
for(int i=0; i<array.length;i++){
System.out.println("第"+i+"個元素是："+array[i]);
}
}
}
陣列排序
在JAVA里面提供了很棒的排序方法，也就是sort( )方法，
Arrays.sort(object);//object也就是陣列的名稱
直接上代碼：
import java.util.Arrays;
public class A{
public static void main(String[] args) {
int array[] = new int[]{1,2,3,4};
Arrays.sort(array);
for(int i = 0;i<array.length;i++){
System.out.println(array[i]);
}
}
}
JAVA里面對于String型別陣列的排序，遵循的原則是數字排在字母前面，大寫字母排在小寫字母前面，
陣列拷貝
Java里面一般可以用copyOf() 和 copyOfRange()來實作對陣列的復制，
我們先來看copyOf():
copyOf(array,int newlength);
array 是要進行復制的陣列
newlength 是復制后的新陣列的長度，如果比原來大，那么空余的地方用0填充，如果小，那么就截取到滿足條件為止，
看一下代碼:
import java.util.Arrays;
public class Copy {
public static void main(String[] args) {
int array[] = new int[]{1,2,3};
int newarray[] = Arrays.copyOf(array,5);
for(int i=0; i<newarray.length; i++){
System.out.println(newarray[i]);
}
}
}
/*
* 輸出結果：
* 1
* 2
* 3
* 0
* 0
* */
然后來看一下copyOfRange的方法：
copyOfRange(array,int fromIndex,int toIndex)
array 是要進行復制的陣列物件
fromIndex 開始復制陣列的索引位置，需要包括
toIndex 是指要復制范圍的最后索引位置，但是是不包括Index的元素
import java.util.Arrays;
public class Copy{
public static void main(String[] args) {
int array[] = new int[]{1,2,3,4,5};
int newarray[] = Arrays.copyOfRange(array,0,3);//前三個元素
for(int i = 0;i<newarray.length;i++){
System.out.println(newarray[i]);
}
}
}
元素查詢
二分法想必大家都聽說過，在JAVA里面也有二分的思想，也就是binarySearch( )方法，二分搜索方法來搜索陣列，獲取我們的指定物件，回傳我們要搜索的元素的索引，
與復制相似，也有兩種類似寫法：
binarySearch(Object[ ],Object key) 和 binarySearch(Object[ ] ,int fromIndex, int toIndex ,Object key )
先看第一個：
binarySearch(Object[ ] array,Object key)
//array 是要進行搜索的陣列
//key 是要進行搜索的值，如果這個key包含在陣列里面，則回傳搜索值得索引，否則回傳 -1 或 " - "
我們看一個栗子：
int array[] = new int[]{4,16,10};
Arrays.sort(arr);
int index = Arrays.binarySearch(array,0,1,7);
我們看一下上面這個程式，我們發現原來的陣列里面是沒有 7 的，我們在回傳值前面加一個 “ - ” ，然后它索引在0~1，我們看 7 是不是應該在 16 前面，在4的后面，經過sort排序之后，我們的順序是{4，10，16}，此時16的位置是 2 ，所以，我們搜索7的回傳值index是 -2，
對于這種方法，應當注意，我們要是找某個元素，那么一定是排順序后，排序好的，如果沒有提前排序，那么結果是無法確定的，
我們再看一個可以查詢到的：
import java.util.Arrays;
public class B{
public static void main(String[] args) {
int array[] = new int[]{5,2,4,3,1};
Arrays.sort(array);
int index = array.binarySearch(array,4);
System.out.println("4的索引位置是"+index);
}
}
//回傳值是 3 ，也就是 4 的索引位置
我們再來看一下 binarySearch(Object[ ] ,int fromIndex, int toIndex ,Object key )
binarySearch(Object[ ] array,int fromIndex, int toIndex ,Object key)
array要檢索的陣列
fromIndex是指定范圍的開始處索引
toIndex 是指范圍內的結束處索引
key 是指要搜索的元素
//使用此方法依然要進行陣列的排序
舉個栗子：
import java.util.Arrays;
public class C{
public static void main(String[] args) {
String str[] = new String[]{"ab","cd","ef","gh"};
Arrays.sort(str);
int index;
index = Arrays.binarySearch(str,0,2,"cd");
System.out.println("cd的索引位置："+index);
}
}
//cd的索引位置：1
排序演算法
筆者對于常見的排序演算法有過詳細的講解： 小白學六大排序演算法（C語言版），思想都是一樣的，這里筆者就不再講解，選取冒泡排序，直接選擇排序，反轉排序這三個方面來用JAVA實作一下 :
冒泡排序
public class BubbleSort {
public static void main(String[] args) {
int[] array = {1,5,6,9,8,7};
BubbleSort bubbleSort = new BubbleSort();
bubbleSort.sort(array);
}
public void sort(int[] array){
for(int i = 1;i<array.length;i++){
for(int j = 0;j<array.length-i;j++){
if(array[j]>array[j+1]){
int temp;
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
showArray(array);
}
public void showArray(int[] array){
for(int i:array){
System.out.print(" "+i);
}
System.out.println();
}
}
直接選擇排序
public class SelectSort {
public static void main(String[] args) {
int array[] = {5,1,2,9,4,6,7};
SelectSort selectSort = new SelectSort();
selectSort.sort(array);
}
public void sort(int[ ] array){
int index;
for(int i = 1; i<array.length; i++){
index = 0;
for(int j=1;j<=array.length-i;j++){
if(array[j]>array[index]){
index = j;
}
}
int temp;
temp = array[array.length-i];
array[array.length-i] = array[index];
array[index] = temp;
}
showArray(array);
}
public void showArray(int[] array){
for(int i:array){
System.out.print(" "+i);
}
System.out.println();
}
}
反轉排序
public class ReverseSort {
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6};
ReverseSort reverseSort = new ReverseSort();
reverseSort.sort(array);
}
public void sort(int[] array){
System.out.println("原陣列：");
showArray(array);
int temp;
for(int i = 0; i<array.length/2; i++){
temp = array[i];
array[i] = array[array.length-1-i];
array[array.length-1-i] = temp;
}
System.out.println("反轉之后：");
showArray(array);
}
public void showArray(int[] array){
for(int i:array){
System.out.print(" "+i);
}
System.out.println();
}
}
對于陣列，這些基本就夠用了，文中若有問題，歡迎大家在評論區留言
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/301265.html
標籤：java