JDK1.8源碼(四)——java.util.Arrays類

一、概述

1、介紹

　　Arrays 類是 JDK1.2 提供的一個工具類，提供處理數組的各種方法，基本上都是靜態方法，能直接通過類名Arrays調用。

二、類源碼

1、asList()方法

　　將一個泛型數組轉化為List集合返回。但是，這個List集合既不是ArrayList實例，也不是Vector實例。它是一個固定長度的 List 集合，是 Arrays 的一個內部類 java.util.Arrays.ArrayList。
　　代碼示例：使用

public class Main {
    public static void main(String[] args) throws Exception {
        Integer[] d = {3, 1, 2};
        final List<Integer> integers = Arrays.asList(d);
        System.out.println(integers);
    }
}

// 結果
[3, 1, 2]

　　源碼示例：

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

private static class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, java.io.Serializable
{
    // 源碼省略，讀者可自行用idea查看
}

　　說明：
　　①、定長列表，只能對其進行查看或者修改，不能進行添加或者刪除操作

public class Main {
    public static void main(String[] args) {
        String[] str = {"a", "b", "c"};
        List<String> list = Arrays.asList(str);
        // 可以進行修改
        list.set(1, "e");
        System.out.println(list.toString()); // [a, e, c]

        list.add("a"); //添加元素會報錯 java.lang.UnsupportedOperationException
    }
}

　　查看源碼發現，該類沒有add() 和 remove()方法。如果對其進行增加或者刪除操作，會調用其父類 AbstractList 對應的方法，而追溯父類的方法最終會拋出 UnsupportedOperationException 異常。源碼如下：

// 類 AbstractList
public boolean add(E e) {
    add(size(), e);
    return true;
}

public void add(int index, E element) {
    throw new UnsupportedOperationException();
}

　　②、引用類型的數組和基本類型的數組區別

public class Main {
    public static void main(String[] args) {
        String[] str = {"a", "b", "c"};
        final List<String> list = Arrays.asList(str);
        System.out.println(list.size()); // 3

        int[] i = {1, 2, 3};
        final List<int[]> ints = Arrays.asList(i);
        System.out.println(ints.size()); // 1
        
        Integer[] in = {1, 2, 3};
        final List<Integer> integers = Arrays.asList(in);
        System.out.println(integers.size()); // 3
    }
}

　　類類型才是泛型，基本數據類型不能作為泛型的參數。讀者根據上面結果自行體會一下。

　　③、返回的是原數組的里的引用，不是獨立出來的集合對象

public class Main {
    public static void main(String[] args) {
        String[] str = {"a", "b", "c"};
        List<String> listStr = Arrays.asList(str);
        System.out.println(Arrays.toString(str)); // [a, b, c]

        listStr.set(0, "d");

        System.out.println(Arrays.toString(str)); // [d, b, c]
    }
}

　　這里，修改的是返回的集合的內容，但是原數組的內容也變化了，所以只是返回了原數組的一個視圖。如果希望返回一個全新的集合，可以如下：

public class Main {
    public static void main(String[] args) {
        String[] str = {"a", "b", "c"};

        ArrayList<String> strings = new ArrayList<>(Arrays.asList(str));
        strings.add("d");

        System.out.println(Arrays.toString(str)); // [a, b, c]
        System.out.println(strings); // [a, b, c, d]
    }
}

2、sort()方法

　　用於數組排序，有一系列重載方法。注意，如果是 Object 類型，需要實現Comparable接口或者傳入一個比較器 Comparator ，使其具有可比性。可以參考這篇。Java比較器。
　　源碼示例：

public static void sort(int[] a) {
    DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}

　　這個方法的源碼很長，分別對數組的長度進行了各種算法的划分，包括快速排序，插入排序，冒泡排序都有使用。詳細源碼可以參考這篇博客。

3、binarySearch()方法

　　用於數組查找，是基於二分查找算法實現，有一系列重載方法，適用於各種基本數據類型以及對象數組。
　　值得注意的是：調用此方法，要求待查找的數組有序。存在，返回元素下標；不存在，返回一個負數（不是 -1）。
　　源碼示例：

public static int binarySearch(int[] a, int key) {
    return binarySearch0(a, 0, a.length, key);
}

// 典型的二分查找算法
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
    }
    
    // 找不到,返回並不是 -1
    return -(low + 1);  // key not found.
}

4、copyOf()方法

　　拷貝數組元素。底層采用 System.arraycopy() 實現，這是一個native方法。
　　注意：這個方法在ArrayList源碼擴容時，也是用的它。
　　代碼示例：

public class Main {
    public static void main(String[] args) {
        int[] old = {1, 3, 2};

        int[] ints = Arrays.copyOf(old, 5);
        System.out.println(Arrays.toString(ints)); // [1, 3, 2, 0, 0]

        int[] ints1 = Arrays.copyOf(old, 1);
        System.out.println(Arrays.toString(ints1)); // [1]
    }
}

　　源碼示例：

// Arrays類
public static int[] copyOf(int[] original, int newLength) {
    int[] copy = new int[newLength];
    System.arraycopy(original, 0, copy, 0,
                    // 長度是舊數組長度 與 新長度 取小
                     Math.min(original.length, newLength));
    return copy;
}

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

　　src：源數組
　　srcPos：源數組要復制的起始位置
　　dest：目的數組
　　destPos：目的數組放置的起始位置
　　length：復制的長度
　　注意：src 和 dest都必須是同類型或者可以進行轉換類型的數組。

5、equals()/deepEquals()方法

　　①、equals
　　用於比較兩個數組中對應位置的每一個元素是否相等。
　　源碼示例：

// 基本數據類型數組比較
public static boolean equals(int[] a, int[] a2) {
    // 引用相等,則相同
    if (a==a2)
        return true;
    if (a==null || a2==null)
        return false;

    int length = a.length;
    // 長度不同,則不相同
    if (a2.length != length)
        return false;

    // 循環依次比較數組中每個元素是否相等
    for (int i=0; i<length; i++)
        if (a[i] != a2[i])
            return false;

    return true;
}

// 引用類型數組比較
public static boolean equals(Object[] a, Object[] a2) {
    if (a==a2)
        return true;
    if (a==null || a2==null)
        return false;

    int length = a.length;
    if (a2.length != length)
        return false;

    for (int i=0; i<length; i++) {
        Object o1 = a[i];
        Object o2 = a2[i];
        
        // 對象相同通過 equals 方法判斷
        if (!(o1==null ? o2==null : o1.equals(o2)))
            return false;
    }

    return true;
}

　　②、deepEquals
　　比較兩個數組的元素是否相等，可以嵌套任意層次的數組。
　　源碼就是遞歸的使用 deepEquals 判斷每一層的數組是否相同。
　　代碼示例：

public class Main {
    public static void main(String[] args) {
        String[][] name1 = {{"G", "a", "o"}, {"H", "u", "a", "n"}, {"j", "i", "e"}};
        String[][] name2 = {{"G", "a", "o"}, {"H", "u", "a", "n"}, {"j", "i", "e"}};

        System.out.println(Arrays.equals(name1, name2));// false
        System.out.println(Arrays.deepEquals(name1, name2));// true
    }
}

6、fill()方法

　　該系列方法用於給數組賦值，並能指定某個范圍賦值。
　　代碼示例：

public class Main {
    public static void main(String[] args) {
        int[] arr = new int[4];
        System.out.println(Arrays.toString(arr)); // [0, 0, 0, 0]

        Arrays.fill(arr, 6);
        System.out.println(Arrays.toString(arr)); // [6, 6, 6, 6]
    }
}

　　源碼示例：

// 不寫注釋也能看懂的代碼
public static void fill(int[] a, int val) {
    for (int i = 0, len = a.length; i < len; i++)
        a[i] = val;
}

public static void fill(int[] a, int fromIndex, int toIndex, int val) {
    rangeCheck(a.length, fromIndex, toIndex);
    for (int i = fromIndex; i < toIndex; i++)
        a[i] = val;
}

7、toString 和 deepToString方法

　　toString 用來打印一維數組的元素，而 deepToString 用來打印多層次嵌套的數組元素。

　　參考文檔：https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html