Java數組的使用以及常用方法

來源：Java核心技術、網上博客

一、數組的概念

數組是一種數據結構， 用來存儲同一類型值的集合。通過一個整型下標可以訪問數組中的每一個值。二維數組是指數組中的數組，二維數組的每一個元素是一個一維數組

二、定義數組的三種方式

1.一維數組

// 數據類型[] 數組名稱 = new 數據類型 [長度];
int[] arr1 = new int[5];
int[] arr2 = new int[]{1,2,3,4,5};
int[] arr3 = {1,2,3,4,5};

注意：

• int[] 變量名也可以寫成int 變量名[]
• 創建一個整形數組時，其中的元素會被默認初始化爲0，boolean 數組的元素會初始化爲 fals% 對象數組的元素則初始化爲一個特殊值 null, 這表示這些元素（還）未存放任何對象。

2.二維數組

int[][] arr = new int[3][5];
int[][] arr = {{2,5},{1},{3,2,4},{1,7,5,9}};

三、數組的遍歷

1.一維數組

數組的遍歷有1.for, 2.while, 3.do…while, 4.增強for循環(foreach)，4種方法，這裏主要說明第4種。

for(數據類型 變量：數組（集合）){

​ 輸出（變量）；

}

int[] a = {2,1,3,4};
for (int temp : a) {
    System.out.println(temp);
}

2.二維數組

二維數組本質上和一維數組的遍歷方式一致，主要搞清楚，什麼代表行數，什麼代表列數

int[][] arr = {{1,2},{3,4},{5,6}};
    for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
    	System.out.println(arr[i][j]);
    }
}

四、數組的常用方法

操作數組的常用類是Arrays，注意不是Array

Array類主要提供了動態創建和訪問 Java 數組的方法。

Arrays包含用來操作數組（比如排序和搜索）的各種方法。此類還包含一個允許將數組作爲列表來查看的靜態工廠

1.toString

返回指定數組的內容的字符串表示形式

// static String toString(Object[] a) 
int[] arr3 = {1,2,3,4,5};
String s = Arrays.toString(arr3);
System.out.println(s);

2.aslist

返回由指定數組支持的固定大小的列表

static List asList(T… a)

String[] str = new String[]{"hello","java"};
List<String> strings = Arrays.asList(str);

注意：

• 看似這個方法返回一個List類型，但其實追蹤到其源碼

public static <T> List<T> asList(T... a) {
	return new ArrayList<>(a);
}

好像是返回了一個ArrayList集合，但是打開這個ArrayList發現這是Arrays自己包下的，所以這就導致了，這個集合不能進行add()、remove()、clear()等方法

• 該方法適用於對象型數據的數組（String、Integer…），如果是基本類型的數組則無法進行轉換

System.out.println(Arrays.asList(new String[]{"a","b"}));
System.out.println(Arrays.asList(new Integer[]{3,4}));
System.out.println(Arrays.asList(new int[]{1,2}));
//輸出
[a, b]
[3, 4]
[[I@1b6d3586]

• 該方法將數組與List列表鏈接起來：當更新其一個時，另一個自動更新

3.arraycopy

這個方法是System包下的，方法原型是

   public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

很顯然這是一個本地方法，從src數組的下標爲srcPos的索引開始，到後面length個元素放到dest數組的下標爲destPos的索引開始的位置。注意：這裏不能超出數組dest的最大存儲空間，否則報ArrayIndexOutOfBoundsException異常

int[] a = new int[]{1,2,3,4,5};
int[] b = new int[]{6,7,8,9,0};
//將a數組下標爲2的數開始，長度爲3結束，複製到數組b下標爲3的數開始，也就是輸出爲[6,7,8,3,4]
System.arraycopy(a,2,b,3,2);
for (int i = 0; i < b.length; i++) {
	System.out.println(b[i]);
}

4.copyOf和copyOFRange方法

這兩個方法是Arrays包下的。方法原型是：

• static short[] copyOf(short[] original, int newLength) (注意：這個方法有很多重載)

從數組的第一個元素開始複製，複製長度爲length，若長度超過數組原長，則超出元素爲默認值0

該方法返回一個數組

int[] c = Arrays.copyOf(a, 3);
for (int i = 0; i < c.length; i++) {
	System.out.println(c[i]);
}

• public static double[] copyOfRange(double []original,int from,int to) (注意：這個方法有很多重載)

original下標爲from的位置開始複製，到to-1的位置結束，返回一個長度爲to-from的數組

5.數組的排序sort

這個方法是Arrays包下的

public static void sort(doule a[]) 將數組按升序全排序
public static void sort(doule a[],int start,int end);從索引爲start到索引爲end-1的位置，升序排序

int[] a = new int[]{5,4,3,7,2};
Arrays.sort(a);
for (int i = 0; i < a.length; i++) {
	System.out.print(a[i] + " ");
}

但是如果要對該數組進行降序排序呢，可以使用sort的另外一個重載方法，傳入一個實現了Comparator接口，重寫了compare方法的實現類。方法原型是：

public static void sort(T[] a, Comparator<? super T> c)

//現了Comparator接口，重寫了compare方法的實現類
class MyComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 > o2 ? -1 : 1;
    }
}
public class demo1 {
    public static void main(String[] args) {
     Integer[] c = new Integer[]{3,2,7,1,5};
        System.out.println();
        Arrays.sort(c,new MyComparator());
        for (int i = 0; i < c.length; i++) {
            System.out.print(c[i] + " ");
        }
    }
}

當然也可以使用java.util.Collections包下的reverseOrder()，這個方法也返回一個Comparator實現類

Integer[] b = new Integer[]{3,2,7,1,5};
    Arrays.sort(b,Collections.reverseOrder());
    for (int i = 0; i < b.length; i++) {
    System.out.print(b[i] + " ");
}

注意：這裏的數組類型不能是基本數據類型，顯然也用到了自動解裝箱。

6.binarySearch

在數組中查找一個數的方法，看這個名字很顯然使用了二分搜索算法，方法原型是

public static int binarySearch(double [] a,double number)

int a[] = {2,1,3,4};
int i = Arrays.binarySearch(a, 3);
System.out.println(i);
//輸出結果是2

查看一下該方法的源碼

// Like public version, but without range checks.
private static int binarySearch0(int[] a, int fromIndex, int toIndex,
int key) {
    int low = fromIndex;
    int high = toIndex - 1;

    while (low <= high) {
    int mid = (low + high) >>> 1;
    int midVal = a[mid];

    if (midVal < key)
    low = mid + 1;
    else if (midVal > key)
    high = mid - 1;
    else
    return mid; // key found
    }
    return -(low + 1);  // key not found
}