Arrays 类包含用于操作数组的各种方法，比如：排序、查找、填充、拷贝、相等判断等。

排序

Arrays.sort() 入参支持各种基本类型的数组，也支持自定义类型的数组，使用了双轴快速排序算法
下面 demo 为自定义类型的数组排序：

  1. @Test
  2. public void test16() {
  4.     // ImmutableList 是 Guava 框架中的类
  5.     ImmutableList<SortDTO> list = ImmutableList.of(
  6.         new SortDTO(500),
  7.         new SortDTO(100),
  8.         new SortDTO(400),
  9.         new SortDTO(200)
  10.     );
  12.     SortDTO[] array = new SortDTO[list.size()];
  13.     list.toArray(array);
  15.     Arrays.sort(array, new Comparator<SortDTO>() {
  16.         @Override
  17.         public int compare(SortDTO o1, SortDTO o2) {
  18.             // 当方法的返回值大于 0 时，就将数组的前一个数和后一个数做交换。
  19.             // 升序的话就o1 - o2
  20.             // 降序的话就o2 - o1
  21.             return o1.getSortTarget() - o2.getSortTarget();
  22.         }
  23.     });
  25.     System.out.println(Arrays.toString(array));
  26. }
  1. public class SortDTO {
  2.     private Integer sortTarget;
  4.     public Integer getSortTarget() {
  5.         return sortTarget;
  6.     }
  8.     public SortDTO(Integer sortTarget) {
  9.         this.sortTarget = sortTarget;
  10.     }
  12.     @Override
  13.     public String toString() {
  14.         return "SortDTO{" +
  15.             "sortTarget=" + sortTarget +
  16.             '}';
  17.     }
  18. }

查找

Arrays.binarySearch() 用于快速从数组中查找出对应的值。
返回参数对应数组下标的值，如果查询不到，则返回负数。
如果被搜索的数组是无序的，一定要先排序，否则二分搜索很有可能搜索不到
binarySearch() 的底层源码实现如下：

  1. private static <T> int binarySearch0(T[] a, int fromIndex, int toIndex,
  2.                                      T key, Comparator<? super T> c) {
  4.     // 比较器 c 为空，直接使用 key 的 Comparable.compareTo
  5.     if (c == null) {
  6.         // 使用内部排序器进行比较的方法
  7.         return binarySearch0(a, fromIndex, toIndex, key);
  8.     }
  10.     int low = fromIndex;
  11.     int high = toIndex - 1;
  13.     // 开始位置小于结束位置，就会一直循环搜索
  14.     while (low <= high) {
  15.         int mid = (low + high) >>> 1;
  16.         T midVal = a[mid];
  18.         // 数组中间值和给定值大小比较
  19.         int cmp = c.compare(midVal, key);
  20.         // cmp < 0，代表中间值小于给定值
  21.         if (cmp < 0) {
  22.             low = mid + 1;
  23.         } else if (cmp > 0) {
  24.             high = mid - 1;
  25.         } else {
  26.             // 找到了
  27.             return mid;
  28.         }
  29.     }
  30.     // 返回值是负数，代表没有找到
  31.     return -(low + 1);
  32. }

拷贝

数组拷贝，有时需要拷贝整个数组，有时需要拷贝部分，比如 ArrayList 在 add（扩容）或 remove（删除元素不是最后一个）操作时，会进行一些拷贝。
拷贝整个数组可以使用 copyOf()，拷贝部分可以使用 copyOfRange()。
copyOfRange() 的底层源码实现如下：

  1. // 注意：拷贝的数组区间是左闭右开的
  2. public static char[] copyOfRange(char[] original, int from, int to) {
  3.     // 需要拷贝的长度
  4.     int newLength = to - from;
  5.     if (newLength < 0)
  6.         throw new IllegalArgumentException(from + " > " + to);
  7.     // 初始化新数组（拷贝的目标数组）
  8.     char[] copy = new char[newLength];
  9.     // 调用 native 方法进行拷贝
  10.     System.arraycopy(original, from, copy, 0,
  11.                      Math.min(original.length - from, newLength));
  12.     return copy;
  13. }

相等判断

Arrays.equals() 用于：比较一维数组，入参数组类型包括了八大基础数据和引用数据类型，入参为引用数据类型时，调用 object.equals() 进行元素的比较。
Arrays.deepEquals() 的入参只支持 Object[]，用于：比较引用数据的多维数组的各元素是否相等，调用了 object.equals() 进行各元素的比较。

以 Object[] 为例说明 equals() 的底层代码实现

  1. public static boolean equals(Object[] a, Object[] a2) {
  2.     if (a==a2)
  3.         return true;
  4.     if (a==null || a2==null)
  5.         return false;
  7.     int length = a.length;
  8.     if (a2.length != length)
  9.         return false;
  11.     for (int i=0; i<length; i++) {
  12.         Object o1 = a[i];
  13.         Object o2 = a2[i];
  14.         if (!(o1==null ? o2==null : o1.equals(o2)))
  15.             return false;
  16.     }
  18.     return true;
  19. }

deepEquals() 的底层源码实现如下：

  1. public static boolean deepEquals(Object[] a1, Object[] a2) {
  2.     if (a1 == a2)
  3.         return true;
  4.     if (a1 == null || a2==null)
  5.         return false;
  6.     int length = a1.length;
  7.     if (a2.length != length)
  8.         return false;
  10.     for (int i = 0; i < length; i++) {
  11.         Object e1 = a1[i];
  12.         Object e2 = a2[i];
  14.         if (e1 == e2)
  15.             continue;
  16.         if (e1 == null)
  17.             return false;
  19.         // Figure out whether the two elements are equal
  20.         // 判断这两个元素是否相等 
  21.         boolean eq = deepEquals0(e1, e2);
  23.         if (!eq)
  24.             return false;
  25.     }
  26.     return true;
  27. }
  1. static boolean deepEquals0(Object e1, Object e2) {
  2.     assert e1 != null;
  3.     boolean eq;
  4.     if (e1 instanceof Object[] && e2 instanceof Object[])
  5.         eq = deepEquals ((Object[]) e1, (Object[]) e2);
  6.     else if (e1 instanceof byte[] && e2 instanceof byte[])
  7.         eq = equals((byte[]) e1, (byte[]) e2);
  8.     else if (e1 instanceof short[] && e2 instanceof short[])
  9.         eq = equals((short[]) e1, (short[]) e2);
  10.     else if (e1 instanceof int[] && e2 instanceof int[])
  11.         eq = equals((int[]) e1, (int[]) e2);
  12.     else if (e1 instanceof long[] && e2 instanceof long[])
  13.         eq = equals((long[]) e1, (long[]) e2);
  14.     else if (e1 instanceof char[] && e2 instanceof char[])
  15.         eq = equals((char[]) e1, (char[]) e2);
  16.     else if (e1 instanceof float[] && e2 instanceof float[])
  17.         eq = equals((float[]) e1, (float[]) e2);
  18.     else if (e1 instanceof double[] && e2 instanceof double[])
  19.         eq = equals((double[]) e1, (double[]) e2);
  20.     else if (e1 instanceof boolean[] && e2 instanceof boolean[])
  21.         eq = equals((boolean[]) e1, (boolean[]) e2);
  22.     else
  23.         eq = e1.equals(e2);
  24.     return eq;
  25. }

数组->集合

把数组转化成集合时，常使用 Arrays.asList(array)，这个方法有两个坑

  • 数组被修改后，会直接影响到集合
  • 不能对集合进行 add、remove 等操作，否则运行时会报 UnsupportedOperationExceptio

以下 demo 用于演示这两个坑：

  1. @Test
  2. public void test18() {
  3.     Integer[] array = new Integer[]{1, 2, 3, 4, 5, 6};
  4.     List<Integer> list = Arrays.asList(array);
  5.     // 打印结果为：1
  6.     System.out.println(list.get(0));
  7.     array[0] = 10;
  8.     // 打印结果为：10
  9.     System.out.println(list.get(0));
  10.     // 抛出 java.lang.UnsupportedOperationException
  11.     list.add(7);
  12. }

Arrays.asList 方法返回的 List 并不是 java.util.ArrayList，而是自己内部的一个静态类，该静态类直接持有数组的引用，并且没有实现 add、remove 等方法，这就是坑的原因。
asList() 的底层源码实现如下：

  1. public static <T> List<T> asList(T... a) {
  2.     // 此处 new 的 ArrayList，并不是 java.util.ArrayList
  3.     // 而是自己内部的静态类
  4.     return new ArrayList<>(a);
  5. }
  7. private static class ArrayList<E> extends AbstractList<E>
  8.     implements RandomAccess, java.io.Serializable {
  9.     private static final long serialVersionUID = -2764017481108945198L;
  10.     // 这里的数组直接指向转化的数组
  11.     private final E[] a;
  13.     ArrayList(E[] array) {
  14.         a = Objects.requireNonNull(array);
  15.     }
  17.     @Override
  18.     public int size() {
  19.         return a.length;
  20.     }
  22.     @Override
  23.     public Object[] toArray() {
  24.         return a.clone();
  25.     }
  27.     @Override
  28.     @SuppressWarnings("unchecked")
  29.     public <T> T[] toArray(T[] a) {
  30.         int size = size();
  31.         if (a.length < size)
  32.             return Arrays.copyOf(this.a, size,
  33.                                  (Class<? extends T[]>) a.getClass());
  34.         System.arraycopy(this.a, 0, a, 0, size);
  35.         if (a.length > size)
  36.             a[size] = null;
  37.         return a;
  38.     }
  40.     @Override
  41.     public E get(int index) {
  42.         return a[index];
  43.     }
  45.     @Override
  46.     public E set(int index, E element) {
  47.         E oldValue = a[index];
  48.         a[index] = element;
  49.         return oldValue;
  50.     }
  52.     @Override
  53.     public int indexOf(Object o) {
  54.         E[] a = this.a;
  55.         if (o == null) {
  56.             for (int i = 0; i < a.length; i++)
  57.                 if (a[i] == null)
  58.                     return i;
  59.         } else {
  60.             for (int i = 0; i < a.length; i++)
  61.                 if (o.equals(a[i]))
  62.                     return i;
  63.         }
  64.         return -1;
  65.     }
  67.     @Override
  68.     public boolean contains(Object o) {
  69.         return indexOf(o) != -1;
  70.     }
  72.     @Override
  73.     public Spliterator<E> spliterator() {
  74.         return Spliterators.spliterator(a, Spliterator.ORDERED);
  75.     }
  77.     @Override
  78.     public void forEach(Consumer<? super E> action) {
  79.         Objects.requireNonNull(action);
  80.         for (E e : a) {
  81.             action.accept(e);
  82.         }
  83.     }
  85.     @Override
  86.     public void replaceAll(UnaryOperator<E> operator) {
  87.         Objects.requireNonNull(operator);
  88.         E[] a = this.a;
  89.         for (int i = 0; i < a.length; i++) {
  90.             a[i] = operator.apply(a[i]);
  91.         }
  92.     }
  94.     @Override
  95.     public void sort(Comparator<? super E> c) {
  96.         Arrays.sort(a, c);
  97.     }
  98. }