Java中的数组工具类Arrays

Arrays就是Java中的数组工具类，它包含了很多静态的方法来对数组进行操作。

下面我们来看看它对数组可以进行哪些操作。

1、将数组转换成一个List

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

实质就是使用数组来创建了一个ArrayList。

2、数组元素查找系列

它提供了一系列的binarySearch函数来对数组进行二分查找。

3、数组复制系列

因为数组在定义的时候就已经固定了其长度，如果需要对数组大小进行扩充，就需要定义一个新的数组然后把旧数组的原始复制到新的数组。在Arrays里面就提供了copyOf和copyOfRange系列函数来进行数组的扩充。

4、数组比较

它提供了两种比较函数，一种是普通的equals函数，一种是深度比较deepEquals函数。

5、填充函数

它提供了fill系列函数来对数组的指定区间进行赋值，默认是整个区间。

public static void fill(int[] array, int start, int end, int value) {
checkFillBounds(array.length, start, end);
for (int i = start; i < end; i++) {
array[i] = value;
}
}

6、hashCode与deepHashCode函数

7、排序函数

它提供了一系列的sort函数进行排序使用

8、toString函数

下面我们来重点看看几类函数的实现

1、复制函数copyOf和copyOfRange

public static <T> T[] copyOf(T[] original, int newLength) {
if (original == null) {
throw new NullPointerException();
}
if (newLength < 0) {
throw new NegativeArraySizeException();
}
return copyOfRange(original, 0, newLength);
}

本质使用的还是copyOfRange函数。

public static <T> T[] copyOfRange(T[] original, int start, int end) {
int originalLength = original.length; // For exception priority compatibility.
if (start > end) {
throw new IllegalArgumentException();
}
if (start < 0 || start > originalLength) {
throw new ArrayIndexOutOfBoundsException();
}
int resultLength = end - start;
int copyLength = Math.min(resultLength, originalLength - start);
// 创建了一个新的数组
T[] result = (T[]) Array.newInstance(original.getClass().getComponentType(), resultLength);
// 将原数组的元素复制到新的数组
System.arraycopy(original, start, result, 0, copyLength);
// 最终将新数组返回
return result;
}

2、数组比较equals和deepEquals函数

public static boolean equals(Object[] array1, Object[] array2) {
// 数组引用是否相同
if (array1 == array2) {
return true;
}

// 数组大小是否相同
if (array1 == null || array2 == null || array1.length != array2.length) {
return false;
}

// 数组内元素比较
for (int i = 0; i < array1.length; i++) {
Object e1 = array1[i], e2 = array2[i];
if (!(e1 == null ? e2 == null : e1.equals(e2))) {
return false;
}
}
return true;
}

它主要比较了三个方面：

1、两个数组引用是否相同

2、如果引用不同，两个数组长度是否相同

3、如果引用不同，数组长度相同，比较数组元素

public static boolean deepEquals(Object[] array1, Object[] array2) {
if (array1 == array2) {
return true;
}
if (array1 == null || array2 == null || array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; i++) {
Object e1 = array1[i], e2 = array2[i];

if (!deepEqualsElements(e1, e2)) {
return false;
}
}
return true;
}

这个跟上面大致相同，只是在元素比较的时候，它使用了深度比较，具体的实现如下。

private static boolean deepEqualsElements(Object e1, Object e2) {
Class<?> cl1, cl2;
// 引用是否相同
if (e1 == e2) {
return true;
}

// 是否为空
if (e1 == null || e2 == null) {
return false;
}

// 如果e1或者e2是一个数组，则返回它的元素类型
// 否则，返回null
cl1 = e1.getClass().getComponentType();
cl2 = e2.getClass().getComponentType();

// 元素类型比较
if (cl1 != cl2) {
return false;
}
// 如果e1不是数组，直接进行元素比较
if (cl1 == null) {
return e1.equals(e2);
}

// 如果元素不是原始类型，继续进行数组深度比较
// 因为e1和e2是数组
if (!cl1.isPrimitive()) {
return deepEquals((Object[]) e1, (Object[]) e2);
}

// 如果元素是原始类型，则直接进行比较
if (cl1.equals(int.class)) {
return equals((int[]) e1, (int[]) e2);
}
if (cl1.equals(char.class)) {
return equals((char[]) e1, (char[]) e2);
}
if (cl1.equals(boolean.class)) {
return equals((boolean[]) e1, (boolean[]) e2);
}
if (cl1.equals(byte.class)) {
return equals((byte[]) e1, (byte[]) e2);
}
if (cl1.equals(long.class)) {
return equals((long[]) e1, (long[]) e2);
}
if (cl1.equals(float.class)) {
return equals((float[]) e1, (float[]) e2);
}
if (cl1.equals(double.class)) {
return equals((double[]) e1, (double[]) e2);
}
return equals((short[]) e1, (short[]) e2);
}

3、排序函数

在Arrays的sort函数中，对char、double、float、int、long、short类型的数组进行排序时，它的内部使用的是插入排序和快速排序。

public static void sort(short[] array) {
DualPivotQuicksort.sort(array);
}

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

private static final int INSERTION_SORT_THRESHOLD = 32;

private static void doSort(int[] a, int left, int right) {
// 如果数组长度小于32时，使用插入排序
if (right - left + 1 < INSERTION_SORT_THRESHOLD) {
for (int i = left + 1; i <= right; i++) {
int ai = a[i];
int j;
for (j = i - 1; j >= left && ai < a[j]; j--) {
a[j + 1] = a[j];
}
a[j + 1] = ai;
}
} else { // 否则使用快速排序
dualPivotQuicksort(a, left, right);
}
}

另外这里的快速排序跟我们普通的快速排序有些不同，感兴趣的可以看看源码。

在Arrays的sort函数中，对Object数组排序时，使用的是使用的是二分排序。