简介

因为Arrays是JDK官方提供的操作数组的工具类，所以很多部分都是重载方法，本篇只举例说明，因为使用的方法是一致的。

代码实现

public class Arrays {
  // 最小数组长度，低于该最小数组长度，并行排序算法将不会进一步划分排序任务
  private static final int MIN_ARRAY_SORT_GRAN = 1 << 13;
  // 私有构造
  private Arrays() {}
  // 它实现了一个基团相互比较的元素的的自然顺序的比较器。 
  static final class NaturalOrder implements Comparator<Object> {
      @SuppressWarnings("unchecked")
      public int compare(Object first, Object second) {
          return ((Comparable<Object>)first).compareTo(second);
      }
      static final NaturalOrder INSTANCE = new NaturalOrder();
  }
  // 将检查fromIndex和toIndex都在范围内，如果他们不抛出异常
  private static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
      if (fromIndex > toIndex) {
          throw new IllegalArgumentException(
              "fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")");
      }
      if (fromIndex < 0) {
          throw new ArrayIndexOutOfBoundsException(fromIndex);
      }
      if (toIndex > arrayLength) {
          throw new ArrayIndexOutOfBoundsException(toIndex);
      }
  }
  // 排序 使用JDK提供的快排正序排序
  public static void sort(int[] a) {
      DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
  }
  // 省略其他重载方法 ... 
  // 平行划分排序 分治合并思想
  public static void parallelSort(byte[] a) {
      int n = a.length, p, g;
      if (n <= MIN_ARRAY_SORT_GRAN ||
          (p = ForkJoinPool.getCommonPoolParallelism()) == 1)
          DualPivotQuicksort.sort(a, 0, n - 1);
      else
          new ArraysParallelSortHelpers.FJByte.Sorter
          (null, a, new byte[n], 0, n, 0,
           ((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
           MIN_ARRAY_SORT_GRAN : g).invoke();
  }
  // 省略其他重载方法 ... 
  // 老归并排序实现可以使用系统属性中选择（与破碎比较兼容性）。 
  // 不能在封闭类的静态布尔由于循环依赖。 为了在未来的版本中删除
  static final class LegacyMergeSort {
      private static final boolean userRequested =
          java.security.AccessController.doPrivileged(
          new sun.security.action.GetBooleanAction(
              "java.util.Arrays.useLegacyMergeSort")).booleanValue();
  }
  // 调用归并排序
  private static void legacyMergeSort(Object[] a) {
      Object[] aux = a.clone();
      mergeSort(aux, a, 0, a.length, 0);
  }
  // 协调参数：在等于或低于其插入排序列表大小将优先于归并使用
  private static final int INSERTIONSORT_THRESHOLD = 7;
  // 归并排序算法
  private static void mergeSort(Object[] src,
                                Object[] dest,
                                int low,
                                int high,
                                int off) {
      int length = high - low;
      // Insertion sort on smallest arrays
      if (length < INSERTIONSORT_THRESHOLD) {
          for (int i=low; i<high; i++)
              for (int j=i; j>low &&
                   ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                  swap(dest, j, j-1);
          return;
      }
      // Recursively sort halves of dest into src
      int destLow  = low;
      int destHigh = high;
      low  += off;
      high += off;
      int mid = (low + high) >>> 1;
      mergeSort(dest, src, low, mid, -off);
      mergeSort(dest, src, mid, high, -off);
      if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
          System.arraycopy(src, low, dest, destLow, length);
          return;
      }
      // Merge sorted halves (now in src) into dest
      for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
          if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
              dest[i] = src[p++];
          else
              dest[i] = src[q++];
      }
  }
  // 交换数据
  private static void swap(Object[] x, int a, int b) {
      Object t = x[a];
      x[a] = x[b];
      x[b] = t;
  }
  public static <T> void parallelPrefix(T[] array, BinaryOperator<T> op) {
      Objects.requireNonNull(op);
      if (array.length > 0)
          new ArrayPrefixHelpers.CumulateTask<>
          (null, op, array, 0, array.length).invoke();
  }
  // 重载方法省略 ....
  // 二分查找算法
  public static int binarySearch(long[] a, long key) {
      return binarySearch0(a, 0, a.length, key);
  }
  // 核心二分算法
  private static int binarySearch0(long[] a, int fromIndex, int toIndex,
                                   long key) {
      int low = fromIndex;
      int high = toIndex - 1;
      while (low <= high) {
          int mid = (low + high) >>> 1;
          long 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.
  }
  // 重载方法省略 ....
  // equals 方法
  public static boolean equals(long[] a, long[] 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;
  }
  // 重载方法省略 ....
  // 填充数组 a 填充为 val
  public static void fill(long[] a, long val) {
      for (int i = 0, len = a.length; i < len; i++)
          a[i] = val;
  }
  // 重载方法省略 ....
  // 数组拷贝 复制指定的数组，截取或用null填充（如果必要）
  public static <T> T[] copyOf(T[] original, int newLength) {
      return (T[]) copyOf(original, newLength, original.getClass());
  }
  // 调用 System.arraycopy()
  public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
      @SuppressWarnings("unchecked")
      T[] copy = ((Object)newType == (Object)Object[].class)
          ? (T[]) new Object[newLength]
          : (T[]) Array.newInstance(newType.getComponentType(), newLength);
      System.arraycopy(original, 0, copy, 0,
                       Math.min(original.length, newLength));
      return copy;
  }
  // 重载方法省略 ....
  // 复制指定的范围指定数组到一个新的数组
  public static <T> T[] copyOfRange(T[] original, int from, int to) {
      return copyOfRange(original, from, to, (Class<? extends T[]>) original.getClass());
  }
  public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
      int newLength = to - from;
      if (newLength < 0)
          throw new IllegalArgumentException(from + " > " + to);
      @SuppressWarnings("unchecked")
      T[] copy = ((Object)newType == (Object)Object[].class)
          ? (T[]) new Object[newLength]
          : (T[]) Array.newInstance(newType.getComponentType(), newLength);
      System.arraycopy(original, from, copy, 0,
                       Math.min(original.length - from, newLength));
      return copy;
  }
  // 重载方法省略 ....
  // 返回List数组 调用 下面的 ArrayList<>
  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
  {
      private static final long serialVersionUID = -2764017481108945198L;
      private final E[] a;
      ArrayList(E[] array) {
          a = Objects.requireNonNull(array);
      }
      @Override
      public int size() {
          return a.length;
      }
      @Override
      public Object[] toArray() {
          return a.clone();
      }
      @Override
      @SuppressWarnings("unchecked")
      public <T> T[] toArray(T[] a) {
          int size = size();
          if (a.length < size)
              return Arrays.copyOf(this.a, size,
                                   (Class<? extends T[]>) a.getClass());
          System.arraycopy(this.a, 0, a, 0, size);
          if (a.length > size)
              a[size] = null;
          return a;
      }
      @Override
      public E get(int index) {
          return a[index];
      }
      @Override
      public E set(int index, E element) {
          E oldValue = a[index];
          a[index] = element;
          return oldValue;
      }
      @Override
      public int indexOf(Object o) {
          E[] a = this.a;
          if (o == null) {
              for (int i = 0; i < a.length; i++)
                  if (a[i] == null)
                      return i;
          } else {
              for (int i = 0; i < a.length; i++)
                  if (o.equals(a[i]))
                      return i;
          }
          return -1;
      }
      @Override
      public boolean contains(Object o) {
          return indexOf(o) != -1;
      }
      @Override
      public Spliterator<E> spliterator() {
          return Spliterators.spliterator(a, Spliterator.ORDERED);
      }
      @Override
      public void forEach(Consumer<? super E> action) {
          Objects.requireNonNull(action);
          for (E e : a) {
              action.accept(e);
          }
      }
      @Override
      public void replaceAll(UnaryOperator<E> operator) {
          Objects.requireNonNull(operator);
          E[] a = this.a;
          for (int i = 0; i < a.length; i++) {
              a[i] = operator.apply(a[i]);
          }
      }
      @Override
      public void sort(Comparator<? super E> c) {
          Arrays.sort(a, c);
      }
  }
  // hashCode
  public static int hashCode(long a[]) {
      if (a == null)
          return 0;
      int result = 1;
      for (long element : a) {
          int elementHash = (int)(element ^ (element >>> 32));
          result = 31 * result + elementHash;
      }
      return result;
  }
  // 省略重载方法 ...
  // 深度 HashCode
  // 返回基于指定数组的“深层内容”哈希码
  public static int deepHashCode(Object a[]) {
      if (a == null)
          return 0;
      int result = 1;
      for (Object element : a) {
          int elementHash = 0;
          if (element instanceof Object[])
              elementHash = deepHashCode((Object[]) element);
          else if (element instanceof byte[])
              elementHash = hashCode((byte[]) element);
          else if (element instanceof short[])
              elementHash = hashCode((short[]) element);
          else if (element instanceof int[])
              elementHash = hashCode((int[]) element);
          else if (element instanceof long[])
              elementHash = hashCode((long[]) element);
          else if (element instanceof char[])
              elementHash = hashCode((char[]) element);
          else if (element instanceof float[])
              elementHash = hashCode((float[]) element);
          else if (element instanceof double[])
              elementHash = hashCode((double[]) element);
          else if (element instanceof boolean[])
              elementHash = hashCode((boolean[]) element);
          else if (element != null)
              elementHash = element.hashCode();
          result = 31 * result + elementHash;
      }
      return result;
  }
  // 深度比较
  public static boolean deepEquals(Object[] a1, Object[] a2) {
      if (a1 == a2)
          return true;
      if (a1 == null || a2==null)
          return false;
      int length = a1.length;
      if (a2.length != length)
          return false;
      for (int i = 0; i < length; i++) {
          Object e1 = a1[i];
          Object e2 = a2[i];
          if (e1 == e2)
              continue;
          if (e1 == null)
              return false;
          // Figure out whether the two elements are equal
          boolean eq = deepEquals0(e1, e2);
          if (!eq)
              return false;
      }
      return true;
  }
  // 辅助方法
  static boolean deepEquals0(Object e1, Object e2) {
      assert e1 != null;
      boolean eq;
      if (e1 instanceof Object[] && e2 instanceof Object[])
          eq = deepEquals ((Object[]) e1, (Object[]) e2);
      else if (e1 instanceof byte[] && e2 instanceof byte[])
          eq = equals((byte[]) e1, (byte[]) e2);
      else if (e1 instanceof short[] && e2 instanceof short[])
          eq = equals((short[]) e1, (short[]) e2);
      else if (e1 instanceof int[] && e2 instanceof int[])
          eq = equals((int[]) e1, (int[]) e2);
      else if (e1 instanceof long[] && e2 instanceof long[])
          eq = equals((long[]) e1, (long[]) e2);
      else if (e1 instanceof char[] && e2 instanceof char[])
          eq = equals((char[]) e1, (char[]) e2);
      else if (e1 instanceof float[] && e2 instanceof float[])
          eq = equals((float[]) e1, (float[]) e2);
      else if (e1 instanceof double[] && e2 instanceof double[])
          eq = equals((double[]) e1, (double[]) e2);
      else if (e1 instanceof boolean[] && e2 instanceof boolean[])
          eq = equals((boolean[]) e1, (boolean[]) e2);
      else
          eq = e1.equals(e2);
      return eq;
  }
  // toString 方法
  public static String toString(long[] 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(", ");
      }
  }
  // 省略重载方法 ...
  // 深度 toString
  public static String deepToString(Object[] a) {
      if (a == null)
          return "null";
      int bufLen = 20 * a.length;
      if (a.length != 0 && bufLen <= 0)
          bufLen = Integer.MAX_VALUE;
      StringBuilder buf = new StringBuilder(bufLen);
      deepToString(a, buf, new HashSet<Object[]>());
      return buf.toString();
  }
  // 省略重载方法 ...
  // 置指定的数组中的所有元素，使用所提供的生成器函数来计算每个元素。
  public static <T> void setAll(T[] array, IntFunction<? extends T> generator) {
      Objects.requireNonNull(generator);
      for (int i = 0; i < array.length; i++)
          array[i] = generator.apply(i);
  }
  // 设置指定的数组的所有元素，并行地使用所提供的生成器函数来计算每个元素。
  public static <T> void parallelSetAll(T[] array, IntFunction<? extends T> generator) {
      Objects.requireNonNull(generator);
      IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.apply(i); });
  }
  // 返回一个Spliterator覆盖所有指定数组
  public static <T> Spliterator<T> spliterator(T[] array) {
      return Spliterators.spliterator(array,
                                      Spliterator.ORDERED | Spliterator.IMMUTABLE);
  }
  // 返回一个Spliterator.OfInt覆盖所有指定数组
  public static Spliterator.OfInt spliterator(int[] array) {
      return Spliterators.spliterator(array,
                                      Spliterator.ORDERED | Spliterator.IMMUTABLE);
  }
  // JDK8 新特性 Stream 流
  public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
      return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);
  }
}

注意点

```java public class ArraysTest { public static void main(String[] args) {

  List<String> list = Arrays.asList("1", "@", "#");
  System.out.println(list.get(1));
  list.add("2");

} }

// Exception in thread “main” java.lang.UnsupportedOperationException ```

Arrays.asList 内部实现是自行实现的，其不支持添加，所以其是只读的。

总结
Arrays工具类的方法共计5000多行，但是大部分都是重载方法
通过抽取公共部分来看，我们可以发现只要掌握了这些基本方法，也就掌握了Arrays类

Base-Java

🎉 Arrays

简介

代码实现

注意点

总结