前言

前面我学习了一些简单的排序算法，实际上在Java中已经有了一些比较方便的工具类。每次自己写的话可能有点麻烦。java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。

常用方法

方法名	作用
boolean equals(int[] a,int[] b)	判断两个数组是否香等。
String toString(int[] a)	输出数组信息。
void fill(int[] a,int val)	将指定值填充到数组中。
void sort(int[] a)	对数组进行排序。
int binaraySearch(int[] a,int key)	对排序后的数组进行二分法检索指定的值。

Arrays.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;
}

Arrays.toString

源码

public static String toString(int[] a) {
    if (a == null)
        return "null";
    int iMax = a.length - 1;
    if (iMax == -1)
        return "[]";

    StringBuilder b = new StringBuilder();
    b.append('[');
    for (int i = 0; ; i++) {
        b.append(a[i]);
        if (i == iMax)
            return b.append(']').toString();
        b.append(", ");
    }
}

Arrays.fill

源码：会把整个数组的元素全都指定一个值

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

Arrays.sort

源码：底层会使用一个快速排序。

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

Arrays.binarySearch

源码：就是二分查找

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
    }
    return -(low + 1);  // key not found.
}

测试

package arrayTest;

import java.util.Arrays;

public class Demo13 {
    public static void main(String[] args) {
        int[] arr1 = new int[10];
        int[] arr2 = new int[10];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = (int) (Math.random() * 100);
            arr2[i] = (int) (Math.random() * 100);
        }
        System.out.println("是否相等：" + Arrays.equals(arr1, arr2));
        System.out.println("fill之前：" + Arrays.toString(arr1));
        Arrays.fill(arr1, 10);
        System.out.println("fill之后：" + Arrays.toString(arr1));
        System.out.println("sort之前：" + Arrays.toString(arr2));
        Arrays.sort(arr2);
        System.out.println("sort之后：" + Arrays.toString(arr2));
        int key = (int) (Math.random() * 100);
        System.out.println("key:" + key);
        int index = Arrays.binarySearch(arr2, key);
        System.out.println("索引：" + index);
    }
}

结果：

是否相等：false
fill之前：[51, 61, 69, 49, 54, 97, 86, 65, 17, 75]
fill之后：[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
sort之前：[20, 55, 18, 70, 51, 97, 36, 82, 52, 73]
sort之后：[18, 20, 36, 51, 52, 55, 70, 73, 82, 97]
key:51
索引：3