Arrays (Java Platform SE 8 )

java.lang.Object
- java.util.Arrays

```
public class Arrays
extends Object
```
该类包含用于操作数组的各种方法（如排序和搜索）。该类还包含一个静态工厂，可以将数组视为列表。
如果指定的数组引用为空，则该类中的方法都抛出一个NullPointerException ，除非另有说明。

该类中包含的方法的文档包括实现的简要描述。这些描述应被视为实施说明 ，而不是说明书的一部分 。只要规范本身得到遵守，实现者就可以随意替代其他算法。（例如，sort(Object[])使用的sort(Object[])不一定是MergeSort，但它必须是稳定的 。）

这个班是Java Collections Framework的成员。

从以下版本开始：

1.2

方法摘要

所有方法静态方法具体的方法
Modifier and Type	Method and Description
`static <T> List<T>`	`asList(T... a)` 返回由指定数组支持的固定大小的列表。
`static int`	`binarySearch(byte[] a, byte key)` 使用二进制搜索算法搜索指定值的指定字节数组。
`static int`	`binarySearch(byte[] a, int fromIndex, int toIndex, byte key)` 使用二进制搜索算法搜索指定值的指定字节数组的范围。
`static int`	`binarySearch(char[] a, char key)` 使用二进制搜索算法搜索指定数组的指定值。
`static int`	`binarySearch(char[] a, int fromIndex, int toIndex, char key)` 使用二分搜索算法搜索指定值的指定数组的范围。
`static int`	`binarySearch(double[] a, double key)` 使用二进制搜索算法搜索指定值的指定数组的双精度值。
`static int`	`binarySearch(double[] a, int fromIndex, int toIndex, double key)` 使用二分搜索算法搜索指定值的指定数组的双精度范围。
`static int`	`binarySearch(float[] a, float key)` 使用二叉搜索算法搜索指定数组的浮点数。
`static int`	`binarySearch(float[] a, int fromIndex, int toIndex, float key)` 使用二分搜索算法搜索指定数组的浮点数范围。
`static int`	`binarySearch(int[] a, int key)` 使用二叉搜索算法搜索指定的int数组的指定值。
`static int`	`binarySearch(int[] a, int fromIndex, int toIndex, int key)` 使用二叉搜索算法搜索指定值的指定数组的范围。
`static int`	`binarySearch(long[] a, int fromIndex, int toIndex, long key)` 使用二分搜索算法搜索指定值的指定数组的范围。
`static int`	`binarySearch(long[] a, long key)` 使用二进制搜索算法搜索指定数组的指定数组。
`static int`	`binarySearch(Object[] a, int fromIndex, int toIndex, Object key)` 使用二进制搜索算法搜索指定对象的指定数组的范围。
`static int`	`binarySearch(Object[] a, Object key)` 使用二叉搜索算法搜索指定对象的指定数组。
`static int`	`binarySearch(short[] a, int fromIndex, int toIndex, short key)` 使用二进制搜索算法搜索指定值的指定数组的短整型范围。
`static int`	`binarySearch(short[] a, short key)` 使用二进制搜索算法搜索指定值的指定数组的指定值。
`static <T> int`	`binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)` 使用二进制搜索算法搜索指定对象的指定数组的范围。
`static <T> int`	`binarySearch(T[] a, T key, Comparator<? super T> c)` 使用二叉搜索算法搜索指定对象的指定数组。
`static boolean[]`	`copyOf(boolean[] original, int newLength)` 使用 `false` （如有必要）复制指定的数组，截断或填充，以使副本具有指定的长度。
`static byte[]`	`copyOf(byte[] original, int newLength)` 复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
`static char[]`	`copyOf(char[] original, int newLength)` 复制指定的数组，截断或填充空字符（如有必要），以便复制具有指定的长度。
`static double[]`	`copyOf(double[] original, int newLength)` 复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
`static float[]`	`copyOf(float[] original, int newLength)` 复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
`static int[]`	`copyOf(int[] original, int newLength)` 复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
`static long[]`	`copyOf(long[] original, int newLength)` 复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
`static short[]`	`copyOf(short[] original, int newLength)` 复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
`static <T> T[]`	`copyOf(T[] original, int newLength)` 复制指定的数组，用空值截断或填充（如有必要），以便复制具有指定的长度。
`static <T,U> T[]`	`copyOf(U[] original, int newLength, 类<? extends T[]> newType)` 复制指定的数组，用空值截断或填充（如有必要），以便复制具有指定的长度。
`static boolean[]`	`copyOfRange(boolean[] original, int from, int to)` 将指定数组的指定范围复制到新数组中。
`static byte[]`	`copyOfRange(byte[] original, int from, int to)` 将指定数组的指定范围复制到新数组中。
`static char[]`	`copyOfRange(char[] original, int from, int to)` 将指定数组的指定范围复制到新数组中。
`static double[]`	`copyOfRange(double[] original, int from, int to)` 将指定数组的指定范围复制到新数组中。
`static float[]`	`copyOfRange(float[] original, int from, int to)` 将指定数组的指定范围复制到新数组中。
`static int[]`	`copyOfRange(int[] original, int from, int to)` 将指定数组的指定范围复制到新数组中。
`static long[]`	`copyOfRange(long[] original, int from, int to)` 将指定数组的指定范围复制到新数组中。
`static short[]`	`copyOfRange(short[] original, int from, int to)` 将指定数组的指定范围复制到新数组中。
`static <T> T[]`	`copyOfRange(T[] original, int from, int to)` 将指定数组的指定范围复制到新数组中。
`static <T,U> T[]`	`copyOfRange(U[] original, int from, int to, 类<? extends T[]> newType)` 将指定数组的指定范围复制到新数组中。
`static boolean`	`deepEquals(Object[] a1, Object[] a2)` 如果两个指定的数组彼此深度相等，则返回 `true` 。
`static int`	`deepHashCode(Object[] a)` 根据指定数组的“深度内容”返回哈希码。
`static String`	`deepToString(Object[] a)` 返回指定数组的“深度内容”的字符串表示形式。
`static boolean`	`equals(boolean[] a, boolean[] a2)` 如果两个指定的布尔数组彼此相等，则返回 `true` 。
`static boolean`	`equals(byte[] a, byte[] a2)` 如果两个指定的字节数组彼此相等，则返回 `true` 。
`static boolean`	`equals(char[] a, char[] a2)` 如果两个指定的字符数组彼此相等，则返回 `true` 。
`static boolean`	`equals(double[] a, double[] a2)` 如果两个指定的双精度数组彼此相等，则返回 `true` 。
`static boolean`	`equals(float[] a, float[] a2)` 如果两个指定的浮动数组彼此相等，则返回 `true` 。
`static boolean`	`equals(int[] a, int[] a2)` 如果两个指定的int数组彼此相等，则返回 `true` 。
`static boolean`	`equals(long[] a, long[] a2)` 如果两个指定的longs数组彼此相等，则返回 `true` 。
`static boolean`	`equals(Object[] a, Object[] a2)` 如果两个指定的对象数组彼此相等，则返回 `true` 。
`static boolean`	`equals(short[] a, short[] a2)` 如果两个指定的短裤阵列彼此相等，则返回 `true` 。
`static void`	`fill(boolean[] a, boolean val)` 将指定的布尔值分配给指定的布尔数组的每个元素。
`static void`	`fill(boolean[] a, int fromIndex, int toIndex, boolean val)` 将指定的布尔值分配给指定数组布尔值的指定范围的每个元素。
`static void`	`fill(byte[] a, byte val)` 将指定的字节值分配给指定字节数组的每个元素。
`static void`	`fill(byte[] a, int fromIndex, int toIndex, byte val)` 将指定的字节值分配给指定字节数组的指定范围的每个元素。
`static void`	`fill(char[] a, char val)` 将指定的char值分配给指定的char数组的每个元素。
`static void`	`fill(char[] a, int fromIndex, int toIndex, char val)` 将指定的char值分配给指定的char数组的指定范围的每个元素。
`static void`	`fill(double[] a, double val)` 将指定的double值分配给指定的双精度数组的每个元素。
`static void`	`fill(double[] a, int fromIndex, int toIndex, double val)` 将指定的double值分配给指定的双精度数组范围的每个元素。
`static void`	`fill(float[] a, float val)` 将指定的float值分配给指定的浮点数组的每个元素。
`static void`	`fill(float[] a, int fromIndex, int toIndex, float val)` 将指定的浮点值分配给指定的浮点数组的指定范围的每个元素。
`static void`	`fill(int[] a, int val)` 将指定的int值分配给指定的int数组的每个元素。
`static void`	`fill(int[] a, int fromIndex, int toIndex, int val)` 将指定的int值分配给指定的int数组的指定范围的每个元素。
`static void`	`fill(long[] a, int fromIndex, int toIndex, long val)` 将指定的long值分配给指定的longs数组的指定范围的每个元素。
`static void`	`fill(long[] a, long val)` 将指定的long值分配给指定的longs数组的每个元素。
`static void`	`fill(Object[] a, int fromIndex, int toIndex, Object val)` 将指定的对象引用分配给指定的对象数组的指定范围的每个元素。
`static void`	`fill(Object[] a, Object val)` 将指定的对象引用分配给指定的对象数组的每个元素。
`static void`	`fill(short[] a, int fromIndex, int toIndex, short val)` 将指定的短值分配给指定的短裤数组的指定范围的每个元素。
`static void`	`fill(short[] a, short val)` 将指定的短值分配给指定的短裤数组的每个元素。
`static int`	`hashCode(boolean[] a)` 根据指定数组的内容返回哈希码。
`static int`	`hashCode(byte[] a)` 根据指定数组的内容返回哈希码。
`static int`	`hashCode(char[] a)` 根据指定数组的内容返回哈希码。
`static int`	`hashCode(double[] a)` 根据指定数组的内容返回哈希码。
`static int`	`hashCode(float[] a)` 根据指定数组的内容返回哈希码。
`static int`	`hashCode(int[] a)` 根据指定数组的内容返回哈希码。
`static int`	`hashCode(long[] a)` 根据指定数组的内容返回哈希码。
`static int`	`hashCode(Object[] a)` 根据指定数组的内容返回哈希码。
`static int`	`hashCode(short[] a)` 根据指定数组的内容返回哈希码。
`static void`	`parallelPrefix(double[] array, DoubleBinaryOperator op)` 使用提供的功能，并行地计算给定阵列的每个元素。
`static void`	`parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)` 对于数组的给定子范围执行 `parallelPrefix(double[], DoubleBinaryOperator)` 。
`static void`	`parallelPrefix(int[] array, IntBinaryOperator op)` 使用提供的功能，并行地计算给定阵列的每个元素。
`static void`	`parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)` 对于数组的给定子范围执行 `parallelPrefix(int[], IntBinaryOperator)` 。
`static void`	`parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)` 对于数组的给定子范围执行 `parallelPrefix(long[], LongBinaryOperator)` 。
`static void`	`parallelPrefix(long[] array, LongBinaryOperator op)` 使用提供的功能，并行地计算给定阵列的每个元素。
`static <T> void`	`parallelPrefix(T[] array, BinaryOperator<T> op)` 使用提供的功能，并行地计算给定阵列的每个元素。
`static <T> void`	`parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)` 对于数组的给定子范围执行 `parallelPrefix(Object[], BinaryOperator)` 。
`static void`	`parallelSetAll(double[] array, IntToDoubleFunction generator)` 使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
`static void`	`parallelSetAll(int[] array, IntUnaryOperator generator)` 使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
`static void`	`parallelSetAll(long[] array, IntToLongFunction generator)` 使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
`static <T> void`	`parallelSetAll(T[] array, IntFunction<? extends T> generator)` 使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
`static void`	`parallelSort(byte[] a)` 按照数字顺序排列指定的数组。
`static void`	`parallelSort(byte[] a, int fromIndex, int toIndex)` 按照数字顺序排列数组的指定范围。
`static void`	`parallelSort(char[] a)` 按照数字顺序排列指定的数组。
`static void`	`parallelSort(char[] a, int fromIndex, int toIndex)` 按照数字顺序排列数组的指定范围。
`static void`	`parallelSort(double[] a)` 按照数字顺序排列指定的数组。
`static void`	`parallelSort(double[] a, int fromIndex, int toIndex)` 按照数字顺序排列数组的指定范围。
`static void`	`parallelSort(float[] a)` 按照数字顺序排列指定的数组。
`static void`	`parallelSort(float[] a, int fromIndex, int toIndex)` 按照数字顺序排列数组的指定范围。
`static void`	`parallelSort(int[] a)` 按照数字顺序排列指定的数组。
`static void`	`parallelSort(int[] a, int fromIndex, int toIndex)` 按照数字顺序排列数组的指定范围。
`static void`	`parallelSort(long[] a)` 按照数字顺序排列指定的数组。
`static void`	`parallelSort(long[] a, int fromIndex, int toIndex)` 按照数字顺序排列数组的指定范围。
`static void`	`parallelSort(short[] a)` 按照数字顺序排列指定的数组。
`static void`	`parallelSort(short[] a, int fromIndex, int toIndex)` 按照数字顺序排列数组的指定范围。
`static <T extends Comparable<? super T>> void`	`parallelSort(T[] a)` 对指定对象升序排列的阵列，根据natural ordering的元素。
`static <T> void`	`parallelSort(T[] a, Comparator<? super T> cmp)` 根据指定的比较器引发的顺序对指定的对象数组进行排序。
`static <T extends Comparable<? super T>> void`	`parallelSort(T[] a, int fromIndex, int toIndex)` 对指定对象升序排列的数组的指定范围内，根据natural ordering的元素。
`static <T> void`	`parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)` 根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序。
`static void`	`setAll(double[] array, IntToDoubleFunction generator)` 使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
`static void`	`setAll(int[] array, IntUnaryOperator generator)` 使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
`static void`	`setAll(long[] array, IntToLongFunction generator)` 使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
`static <T> void`	`setAll(T[] array, IntFunction<? extends T> generator)` 使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
`static void`	`sort(byte[] a)` 按照数字顺序排列指定的数组。
`static void`	`sort(byte[] a, int fromIndex, int toIndex)` 按升序排列数组的指定范围。
`static void`	`sort(char[] a)` 按照数字顺序排列指定的数组。
`static void`	`sort(char[] a, int fromIndex, int toIndex)` 按升序排列数组的指定范围。
`static void`	`sort(double[] a)` 按照数字顺序排列指定的数组。
`static void`	`sort(double[] a, int fromIndex, int toIndex)` 按升序排列数组的指定范围。
`static void`	`sort(float[] a)` 按照数字顺序排列指定的数组。
`static void`	`sort(float[] a, int fromIndex, int toIndex)` 按升序排列数组的指定范围。
`static void`	`sort(int[] a)` 按照数字顺序排列指定的数组。
`static void`	`sort(int[] a, int fromIndex, int toIndex)` 按升序排列数组的指定范围。
`static void`	`sort(long[] a)` 按照数字顺序排列指定的数组。
`static void`	`sort(long[] a, int fromIndex, int toIndex)` 按升序排列数组的指定范围。
`static void`	`sort(Object[] a)` 对指定对象升序排列的阵列，根据natural ordering的元素。
`static void`	`sort(Object[] a, int fromIndex, int toIndex)` 对指定对象升序排列的数组的指定范围内，根据natural ordering的元素。
`static void`	`sort(short[] a)` 按照数字顺序排列指定的数组。
`static void`	`sort(short[] a, int fromIndex, int toIndex)` 按升序排列数组的指定范围。
`static <T> void`	`sort(T[] a, Comparator<? super T> c)` 根据指定的比较器引发的顺序对指定的对象数组进行排序。
`static <T> void`	`sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)` 根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序。
`static Spliterator.OfDouble`	`spliterator(double[] array)` 返回`Spliterator.OfDouble`覆盖所有指定数组。
`static Spliterator.OfDouble`	`spliterator(double[] array, int startInclusive, int endExclusive)` 返回`Spliterator.OfDouble`覆盖指定数组的指定范围内。
`static Spliterator.OfInt`	`spliterator(int[] array)` 返回`Spliterator.OfInt`覆盖所有指定数组。
`static Spliterator.OfInt`	`spliterator(int[] array, int startInclusive, int endExclusive)` 返回`Spliterator.OfInt`覆盖指定数组的指定范围内。
`static Spliterator.OfLong`	`spliterator(long[] array)` 返回`Spliterator.OfLong`覆盖所有指定数组。
`static Spliterator.OfLong`	`spliterator(long[] array, int startInclusive, int endExclusive)` 返回`Spliterator.OfLong`覆盖指定数组的指定范围内。
`static <T> Spliterator<T>`	`spliterator(T[] array)` 返回`Spliterator`覆盖所有指定数组。
`static <T> Spliterator<T>`	`spliterator(T[] array, int startInclusive, int endExclusive)` 返回`Spliterator`覆盖指定数组的指定范围内。
`static DoubleStream`	`stream(double[] array)` 返回顺序`DoubleStream`与指定的数组作为源。
`static DoubleStream`	`stream(double[] array, int startInclusive, int endExclusive)` 返回顺序`DoubleStream`与指定的数组作为源的指定范围。
`static IntStream`	`stream(int[] array)` 返回顺序`IntStream`与指定的数组作为源。
`static IntStream`	`stream(int[] array, int startInclusive, int endExclusive)` 返回顺序`IntStream`与指定的数组作为源的指定范围。
`static LongStream`	`stream(long[] array)` 返回顺序`LongStream`与指定的数组作为源。
`static LongStream`	`stream(long[] array, int startInclusive, int endExclusive)` 返回顺序`LongStream`与指定的数组作为源的指定范围。
`static <T> Stream<T>`	`stream(T[] array)` 返回顺序`Stream`与指定的数组作为源。
`static <T> Stream<T>`	`stream(T[] array, int startInclusive, int endExclusive)` 返回顺序`Stream`与指定的数组作为源的指定范围。
`static String`	`toString(boolean[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(byte[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(char[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(double[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(float[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(int[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(long[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(Object[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(short[] a)` 返回指定数组的内容的字符串表示形式。

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 方法详细信息
  - sort
```
public static void sort(int[] a)
```
    按照数字顺序排列指定的数组。
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
  - sort
```
public static void sort(int[] a,
                        int fromIndex,
                        int toIndex)
```
    按升序排列数组的指定范围。要排序的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。如果fromIndex == toIndex ，要排序的范围是空的。
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（ fromIndex ）的索引
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(long[] a)
```
    按照数字顺序排列指定的数组。
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
  - sort
```
public static void sort(long[] a,
                        int fromIndex,
                        int toIndex)
```
    按升序排列数组的指定范围。要排序的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。如果fromIndex == toIndex ，要排序的范围是空的。
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（ fromIndex ）的索引
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果是 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(short[] a)
```
    按照数字顺序排列指定的数组。
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
  - sort
```
public static void sort(short[] a,
                        int fromIndex,
                        int toIndex)
```
    按升序排列数组的指定范围。要排序的范围从索引延伸fromIndex ，包容，到索引toIndex ，排斥。如果fromIndex == toIndex ，要排序的范围是空的。
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的阵列
    
    fromIndex - 要排序的第一个元素的索引（包括）
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果是 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(char[] a)
```
    按照数字顺序排列指定的数组。
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
  - sort
```
public static void sort(char[] a,
                        int fromIndex,
                        int toIndex)
```
    按升序排列数组的指定范围。要排序的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。如果fromIndex == toIndex ，要排序的范围是空的。
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（ fromIndex ）的索引
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果是 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(byte[] a)
```
    按照数字顺序排列指定的数组。
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
  - sort
```
public static void sort(byte[] a,
                        int fromIndex,
                        int toIndex)
```
    按升序排列数组的指定范围。要排序的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。如果fromIndex == toIndex ，要排序的范围是空的。
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素的索引（包括）
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(float[] a)
```
    按照数字顺序排列指定的数组。
    <关系不提供所有浮动值的总订单： -0.0f == 0.0f是true ，而Float.NaN值比较不小于，大于或等于任何值，甚至本身。该方法使用方法Float.compareTo(java.lang.Float) ： -0.0f处理为小于值0.0f和Float.NaN的总顺序被认为大于任何其他值，并且所有Float.NaN值被视为相等。
    
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
  - sort
```
public static void sort(float[] a,
                        int fromIndex,
                        int toIndex)
```
    按升序排列数组的指定范围。要排序的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。如果fromIndex == toIndex ，要排序的范围是空的。
    所述<关系不能在所有浮点值提供一个总次序： -0.0f == 0.0f是true和Float.NaN值进行比较既不小于，大于，也不等于任何值，甚至本身。该方法使用方法Float.compareTo(java.lang.Float) ： -0.0f处理的总订单被视为小于值0.0f和Float.NaN被认为大于任何其他值，并且所有Float.NaN值被认为是相等的。
    
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（ fromIndex ）的索引
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(double[] a)
```
    按照数字顺序排列指定的数组。
    所述<关系不能在所有的双精度值提供一个总次序： -0.0d == 0.0d是true和Double.NaN值进行比较既不小于，大于，也不等于任何值，甚至本身。该方法使用方法Double.compareTo(java.lang.Double) ： -0.0d处理的总顺序被视为小于值0.0d和Double.NaN被认为大于任何其他值，并且所有Double.NaN值被认为是相等的。
    
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
  - sort
```
public static void sort(double[] a,
                        int fromIndex,
                        int toIndex)
```
    按升序排列数组的指定范围。要排序的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。如果fromIndex == toIndex ，要排序的范围为空。
    <关系不能提供所有双重值的总订单： -0.0d == 0.0d为true ，而Double.NaN值既不小于，大于也不等于任何值，甚至本身。此方法使用方法Double.compareTo(java.lang.Double) ： -0.0d处理的总订单被视为小于值0.0d和Double.NaN认为大于任何其他值，并且所有Double.NaN值被视为相等。
    
    实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（ fromIndex ）的索引
    
    toIndex - 要排序的最后一个元素的索引，排他
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - parallelSort
```
public static void parallelSort(byte[] a)
```
    按照数字顺序排列指定的数组。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法排序。该算法需要一个不大于原始数组大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(byte[] a,
                                int fromIndex,
                                int toIndex)
```
    按照数字顺序排列数组的指定范围。要排序的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。如果fromIndex == toIndex ，要排序的范围是空的。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要不大于原始数组的指定范围的大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素的索引（包括）
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(char[] a)
```
    按照数字顺序排列指定的数组。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要一个不大于原始数组大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(char[] a,
                                int fromIndex,
                                int toIndex)
```
    按照数字顺序排列数组的指定范围。要排序的范围从索引延伸fromIndex ，包容，到索引toIndex ，排斥。如果fromIndex == toIndex ，要排序的范围是空的。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要不大于原始数组的指定范围的大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素的索引（包括）
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果是 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(short[] a)
```
    按照数字顺序排列指定的数组。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要一个不大于原始数组大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(short[] a,
                                int fromIndex,
                                int toIndex)
```
    按照数字顺序排列数组的指定范围。要排序的范围从索引fromIndex扩展到索引toIndex ，排他。如果fromIndex == toIndex ，要排序的范围是空的。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要不大于原始数组的指定范围的大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素的索引（包括）
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(int[] a)
```
    按照数字顺序排列指定的数组。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要一个不大于原始数组大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(int[] a,
                                int fromIndex,
                                int toIndex)
```
    按照数字顺序排列数组的指定范围。要排序的范围从索引延伸fromIndex ，包容，到索引toIndex ，排斥。如果fromIndex == toIndex ，要排序的范围为空。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要不大于原始数组的指定范围的大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（ fromIndex ）的索引
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(long[] a)
```
    按照数字顺序排列指定的数组。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要一个不大于原始数组大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(long[] a,
                                int fromIndex,
                                int toIndex)
```
    按照数字顺序排列数组的指定范围。要排序的范围从索引延伸fromIndex ，包容，到索引toIndex ，排斥。如果fromIndex == toIndex ，要排序的范围是空的。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要不大于原始数组的指定范围的大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（ fromIndex ）的索引
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果是 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(float[] a)
```
    按照数字顺序排列指定的数组。
    <关系不提供所有浮动值的总订单： -0.0f == 0.0f是true ，而Float.NaN值比较不小于，大于，也不等于任何值，甚至本身。此方法使用方法Float.compareTo(java.lang.Float)施加的总顺序： -0.0f被视为小于值0.0f和Float.NaN被认为大于任何其他值，并且所有Float.NaN值被认为是相等的。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要一个不大于原始数组大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(float[] a,
                                int fromIndex,
                                int toIndex)
```
    按照数字顺序排列数组的指定范围。要排序的范围从索引延伸fromIndex ，包容，到索引toIndex ，排斥。如果fromIndex == toIndex ，要排序的范围是空的。
    所述<关系不能在所有浮点值提供一个总次序： -0.0f == 0.0f是true和Float.NaN值进行比较既不小于，大于，也不等于任何值，甚至本身。该方法使用Float.compareTo(java.lang.Float) ： Float.compareTo(java.lang.Float) ： -0.0f处理为小于值0.0f和Float.NaN的总顺序被认为大于任何其他值，并且所有Float.NaN值都被视为相等。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要不大于原始数组的指定范围的大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（ fromIndex ）的索引
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(double[] a)
```
    按照数字顺序排列指定的数组。
    所述<关系不能在所有的双精度值提供一个总次序： -0.0d == 0.0d是true和Double.NaN值进行比较既不小于，大于，也不等于任何值，甚至本身。该方法使用方法Double.compareTo(java.lang.Double) ： -0.0d处理的总顺序被视为小于值0.0d ，并且Double.NaN被认为大于任何其他值，并且所有Double.NaN值被认为相等。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要一个不大于原始数组大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static void parallelSort(double[] a,
                                int fromIndex,
                                int toIndex)
```
    按照数字顺序排列数组的指定范围。要排序的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。如果fromIndex == toIndex ，要排序的范围是空的。
    <关系不会提供所有双重值的总订单： -0.0d == 0.0d为true ，而Double.NaN值既不小于，大于也不等于任何值，甚至本身。该方法使用方法Double.compareTo(java.lang.Double) ： -0.0d处理的总顺序被视为小于值0.0d ，并且Double.NaN被认为大于任何其他值，并且所有Double.NaN值被认为是相等的。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要不大于原始数组的指定范围的大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素的索引（包括）
    
    toIndex - 最后一个要排序的元素的索引
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static <T extends Comparable<? super T>> void parallelSort(T[] a)
```
    对指定对象升序排列的阵列，根据natural ordering的元素。数组中的所有元素必须实现Comparable接口。此外，数组中的所有元素都必须相互可比较 （即， e1.compareTo(e2)不能为ClassCastException中的任何元素e1和e2 ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要一个不大于原始数组大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    异常
    
    ClassCastException - 如果数组包含不 相互比较的元素 （例如，字符串和整数）
    
    IllegalArgumentException - （可选）如果发现数组元素的自然排序违反了Comparable合同
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static <T extends Comparable<? super T>> void parallelSort(T[] a,
                                                                  int fromIndex,
                                                                  int toIndex)
```
    对指定对象升序排列的数组的指定范围内，根据natural ordering的元素。要排序的范围从索引fromIndex扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，要排序的范围为空。）此范围中的所有元素必须实现Comparable接口。此外，该范围内的所有元素必须相互可比较 （即， e1.compareTo(e2)不得为ClassCastException中的任何元素e1和e2 ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要不大于原始数组的指定范围的大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（包括）的索引
    
    toIndex - 要排序的最后一个元素（排他）的索引
    
    异常
    
    IllegalArgumentException - 如果fromIndex > toIndex或（可选）如果发现数组元素的自然排序违反了Comparable合同
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
    
    ClassCastException - 如果数组包含不 相互比较的元素 （例如，字符串和整数）。
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static <T> void parallelSort(T[] a,
                                    Comparator<? super T> cmp)
```
    根据指定的比较器引发的顺序对指定的对象数组进行排序。数组中的所有元素必须通过指定的比较器相互比较 （即c.compare(e1, e2)不能为ClassCastException中的任何元素e1和e2 ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要一个不大于原始数组大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    cmp - 比较器来确定数组的顺序。 A null值表示应使用元素' natural ordering '。
    
    异常
    
    ClassCastException - 如果数组包含使用指定的比较器不 相互比较的元素
    
    IllegalArgumentException - （可选）如果比较方发现违反Comparator合同
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static <T> void parallelSort(T[] a,
                                    int fromIndex,
                                    int toIndex,
                                    Comparator<? super T> cmp)
```
    根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序。要排序的范围从索引fromIndex扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，则排序范围为空。）范围内的所有元素都必须是指定比较相互比较的 （即， c.compare(e1, e2)不得抛出ClassCastException任何元件e1和e2中的范围内）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    Implementation Note:
    
    排序算法是一个并行排序合并，将数组分解为子数组，这些子数组本身被排序然后合并。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。该算法需要不大于原始数组的指定范围的大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（包括）的索引
    
    toIndex - 要排序的最后一个元素（排他）的索引
    
    cmp - 比较器来确定数组的顺序。 A null值表示应使用元素' natural ordering '。
    
    异常
    
    IllegalArgumentException - 如果fromIndex > toIndex或（可选）如果发现数组元素的自然排序违反了Comparable合同
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
    
    ClassCastException - 如果数组包含不 相互比较的元素 （例如，字符串和整数）。
    
    从以下版本开始：
    
    1.8
  - sort
```
public static void sort(Object[] a)
```
    根据其元素的natural ordering ，按照升序排列指定的对象数组。阵列中的所有元素必须实现Comparable接口。此外，数组中的所有元素必须相互可比较 （即， e1.compareTo(e2)不能为ClassCastException中的任何元素e1和e2 ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    实现注意事项：这个实现是一个稳定的，自适应的，迭代的mergeesort，当输入数组被部分排序时，需要比n lg（n）的比较少得多，同时在输入数组被随机排列时提供传统的mergeesort的性能。如果输入数组几乎被排序，则实现需要大致n个比较。临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的n / 2对象引用。
    
    该实现在其输入数组中具有上升和下降的同等优势，并且可以在同一输入数组的不同部分中利用升序和降序。它非常适合合并两个或多个排序的数组：简单地连接数组并排序生成的数组。
    
    该实现根据Tim Peters的Python列表（ TimSort ）进行了改编。它使用Peter McIlroy的“乐观排序和信息理论复杂性”中的技术，在第四届ACM-SIAM离散算法研讨会论文集，pp 467-474，1993年1月。
    
    参数
    
    a - 要排序的数组
    
    异常
    
    ClassCastException - 如果数组包含不 相互比较的元素 （例如，字符串和整数）
    
    IllegalArgumentException - （可选）如果发现数组元素的自然排序违反了Comparable合同
  - sort
```
public static void sort(Object[] a,
                        int fromIndex,
                        int toIndex)
```
    对指定对象升序排列的数组的指定范围内，根据natural ordering的元素。要排序的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，要排序的范围为空。）此范围中的所有元素必须实现Comparable接口。此外，该范围内的所有元素必须相互可比较 （即， e1.compareTo(e2)不能为ClassCastException中的任何元素e1和e2 ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    实现注意事项：这个实现是一个稳定的，自适应的，迭代的mergeesort，当输入数组被部分排序时，需要比n lg（n）的比较少得多，同时在输入数组被随机排列时提供传统的mergeesort的性能。如果输入数组几乎被排序，则实现需要大致n个比较。临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的n / 2对象引用。
    
    该实现在其输入数组中具有上升和下降的同等优势，并且可以在同一输入数组的不同部分中利用升序和降序。它非常适合合并两个或多个排序的数组：简单地连接数组并排序生成的数组。
    
    实施从Tim Peters的Python列表（ TimSort ）进行了改编。它使用Peter McIlroy的“乐观排序和信息理论复杂性”中的技术，在第四届ACM-SIAM离散算法研讨会论文集，pp 467-474，1993年1月。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（包括）的索引
    
    toIndex - 要排序的最后一个元素（排他）的索引
    
    异常
    
    IllegalArgumentException - 如果fromIndex > toIndex或（可选）如果发现数组元素的自然排序违反了Comparable合同
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
    
    ClassCastException - 如果数组包含不 相互比较的元素 （例如，字符串和整数）。
  - sort
```
public static <T> void sort(T[] a,
                            Comparator<? super T> c)
```
    根据指定的比较器引发的顺序对指定的对象数组进行排序。数组中的所有元素必须通过指定的比较器相互比较 （即c.compare(e1, e2)不能为ClassCastException中的任何元素e1和e2 ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    实现注意事项：这个实现是一个稳定的，自适应的，迭代的mergeesort，当输入数组被部分排序时，需要比n lg（n）的比较少得多，同时在输入数组被随机排列时提供传统的mergeesort的性能。如果输入数组几乎被排序，则实现需要大致n个比较。临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的n / 2对象引用。
    
    该实现在其输入数组中具有上升和下降的同等优势，并且可以在同一输入数组的不同部分中利用升序和降序。它非常适合合并两个或多个排序的数组：简单地连接数组并排序生成的数组。
    
    该实现是从Tim Peters的Python列表（ TimSort ）中进行的。它使用Peter McIlroy的“乐观排序和信息理论复杂性”中的技术，在第四届ACM-SIAM离散算法研讨会论文集，pp 467-474，1993年1月。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    c - 比较器确定阵列的顺序。 A null值表示应使用元素' natural ordering '。
    
    异常
    
    ClassCastException - 如果数组包含使用指定比较器不 相互比较的元素
    
    IllegalArgumentException - （可选）如果比较方发现违反Comparator合同
  - sort
```
public static <T> void sort(T[] a,
                            int fromIndex,
                            int toIndex,
                            Comparator<? super T> c)
```
    根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序。要排序的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，则排序范围为空。）范围内的所有元素都必须是指定比较相互比较的 （即， c.compare(e1, e2)不得抛出ClassCastException任何元件e1和e2中的范围内）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    实现注意事项：这个实现是一个稳定的，自适应的，迭代的mergeesort，当输入数组被部分排序时，需要比n lg（n）的比较少得多，同时在输入数组被随机排列时提供传统的mergeesort的性能。如果输入数组几乎被排序，则实现需要大致n个比较。临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的n / 2对象引用。
    
    该实现在其输入数组中具有上升和下降的同等优势，并且可以在同一输入数组的不同部分中利用升序和降序。它非常适合合并两个或多个排序的数组：简单地连接数组并排序生成的数组。
    
    该实现根据Tim Peters的Python列表（ TimSort ）进行了改编。它使用Peter McIlroy的“乐观排序和信息理论复杂性”中的技术，在第四届ACM-SIAM离散算法研讨会论文集，pp 467-474，1993年1月。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（包括）的索引
    
    toIndex - 要排序的最后一个元素（排他）的索引
    
    c - 比较器来确定数组的顺序。 A null值表示应使用元素' natural ordering '。
    
    异常
    
    ClassCastException - 如果数组包含使用指定的比较器不 相互比较的元素。
    
    IllegalArgumentException - 如果fromIndex > toIndex或（可选）如果比较方发现违反Comparator合同
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - parallelPrefix
```
public static <T> void parallelPrefix(T[] array,
                                      BinaryOperator<T> op)
```
    使用提供的功能，并行地计算给定阵列的每个元素。例如，如果数组最初保持[2, 1, 0, 3]并且操作执行添加，则返回时，数组将保持[2, 3, 3, 6] 。并行前缀计算通常比大数组的顺序循环更有效。
    
    参数类型
    
    T - 数组中对象的类
    
    参数
    
    array - 通过此方法就地修改的数组
    
    op - 一种无副作用的关联函数来执行累积
    
    异常
    
    NullPointerException - 如果指定的数组或函数为空
    
    从以下版本开始：
    
    1.8
  - parallelPrefix
```
public static <T> void parallelPrefix(T[] array,
                                      int fromIndex,
                                      int toIndex,
                                      BinaryOperator<T> op)
```
    对于数组的给定子范围执行 parallelPrefix(Object[], BinaryOperator) 。
    
    参数类型
    
    T - 数组中对象的类
    
    参数
    
    array - 数组
    
    fromIndex - 第一个元素的索引（含）
    
    toIndex - 最后一个元素的索引，独占
    
    op - 执行累积的无副作用的关联函数
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > array.length
    
    NullPointerException - 如果指定的数组或函数为空
    
    从以下版本开始：
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(long[] array,
                                  LongBinaryOperator op)
```
    使用提供的功能，并行地计算给定阵列的每个元素。例如，如果阵列最初保持[2, 1, 0, 3]并且操作执行添加，则返回时，数组将保持[2, 3, 3, 6] 。并行前缀计算通常比大数组的顺序循环更有效。
    
    参数
    
    array - 通过此方法被原位修改的数组
    
    op - 一种无副作用的关联函数来执行累积
    
    异常
    
    NullPointerException - 如果指定的数组或函数为空
    
    从以下版本开始：
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(long[] array,
                                  int fromIndex,
                                  int toIndex,
                                  LongBinaryOperator op)
```
    对于数组的给定子范围执行 parallelPrefix(long[], LongBinaryOperator) 。
    
    参数
    
    array - 数组
    
    fromIndex - 第一个元素的索引（包括）
    
    toIndex - 最后一个元素的索引，独占
    
    op - 一种无副作用的关联函数来执行累积
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > array.length
    
    NullPointerException - 如果指定的数组或函数为空
    
    从以下版本开始：
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(double[] array,
                                  DoubleBinaryOperator op)
```
    使用提供的功能，并行地计算给定阵列的每个元素。例如，如果数组最初保持[2.0, 1.0, 0.0, 3.0]并且操作执行添加，则返回时，数组保持[2.0, 3.0, 3.0, 6.0] 。并行前缀计算通常比大数组的顺序循环更有效。
    因为浮点运算可能不是严格关联的，所以返回的结果可能不一致，如果顺序执行操作将获得的值。
    
    参数
    
    array - 通过此方法就地修改的数组
    
    op - 执行累积的无副作用的功能
    
    异常
    
    NullPointerException - 如果指定的数组或函数为空
    
    从以下版本开始：
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(double[] array,
                                  int fromIndex,
                                  int toIndex,
                                  DoubleBinaryOperator op)
```
    对于数组的给定子范围执行 parallelPrefix(double[], DoubleBinaryOperator) 。
    
    参数
    
    array - 数组
    
    fromIndex - 第一个元素的索引（含）
    
    toIndex - 最后一个元素的索引，独占
    
    op - 一种无副作用的关联函数来执行累积
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > array.length
    
    NullPointerException - 如果指定的数组或函数为空
    
    从以下版本开始：
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(int[] array,
                                  IntBinaryOperator op)
```
    使用提供的功能，并行地计算给定阵列的每个元素。例如，如果阵列最初保持[2, 1, 0, 3]并且操作执行添加，则返回时，数组将保持[2, 3, 3, 6] 。并行前缀计算通常比大数组的顺序循环更有效。
    
    参数
    
    array - 通过此方法就地修改的数组
    
    op - 执行累积的无副作用的关联函数
    
    异常
    
    NullPointerException - 如果指定的数组或函数为空
    
    从以下版本开始：
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(int[] array,
                                  int fromIndex,
                                  int toIndex,
                                  IntBinaryOperator op)
```
    对于数组的给定子范围执行 parallelPrefix(int[], IntBinaryOperator) 。
    
    参数
    
    array - 数组
    
    fromIndex - 第一个元素的索引（包括）
    
    toIndex - 最后一个元素的索引，独占
    
    op - 一种无副作用的关联函数来执行累积
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > array.length
    
    NullPointerException - 如果指定的数组或函数为空
    
    从以下版本开始：
    
    1.8
  - binarySearch
```
public static int binarySearch(long[] a,
                               long key)
```
    使用二进制搜索算法搜索指定数组的指定数组。在进行此调用之前，数组必须按照sort(long[])方法进行排序。如果没有排序，结果是未定义的。如果数组包含具有指定值的多个元素，则不能保证将找到哪个元素。
    
    参数
    
    a - 要搜索的数组
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 。如果阵列中的所有元素都小于指定键的第一元件比所述键时，或a.length的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
  - binarySearch
```
public static int binarySearch(long[] a,
                               int fromIndex,
                               int toIndex,
                               long key)
```
    使用二分搜索算法搜索指定值的指定数组的范围。在进行此呼叫之前，范围必须按照sort(long[], int, int)方法进行排序。如果没有排序，结果是未定义的。如果范围包含具有指定值的多个元素，则不能保证将找到哪个元素。
    
    参数
    
    a - 要搜索的数组
    
    fromIndex - 要搜索的第一个元素（包括）的索引
    
    toIndex - 要搜索的最后一个元素（排他）的索引
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在指定范围内的数组中; 否则， (-(insertion point) - 1) 。如果在范围内的所有元素都小于指定的键在比所述键时，或toIndex的范围中的第一个元素的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 or toIndex > a.length
    
    从以下版本开始：
    
    1.6
  - binarySearch
```
public static int binarySearch(int[] a,
                               int key)
```
    使用二叉搜索算法搜索指定的int数组的指定值。在进行此调用之前，必须对数组进行排序（如sort(int[])方法）。如果没有排序，结果是未定义的。如果数组包含具有指定值的多个元素，则不能保证将找到哪个元素。
    
    参数
    
    a - 要搜索的数组
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 。如果阵列中的所有元素都小于指定键的第一元件比所述键时，或a.length的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
  - binarySearch
```
public static int binarySearch(int[] a,
                               int fromIndex,
                               int toIndex,
                               int key)
```
    使用二叉搜索算法搜索指定值的指定数组的范围。在进行此呼叫之前，范围必须按照sort(int[], int, int)方法进行排序。如果没有排序，结果是未定义的。如果范围包含具有指定值的多个元素，则不能保证将找到哪个元素。
    
    参数
    
    a - 要搜索的数组
    
    fromIndex - 要搜索的第一个元素（包括）的索引
    
    toIndex - 要搜索的最后一个元素（排他）的索引
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在指定范围内的数组中; 否则， (-(insertion point) - 1) 。如果在范围内的所有元素都小于指定的键在比所述键时，或toIndex的范围中的第一个元素的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 or toIndex > a.length
    
    从以下版本开始：
    
    1.6
  - binarySearch
```
public static int binarySearch(short[] a,
                               short key)
```
    使用二进制搜索算法搜索指定值的指定数组的指定值。在进行此调用之前，必须对数组进行排序（按照sort(short[])方法）。如果没有排序，结果是未定义的。如果数组包含具有指定值的多个元素，则不能保证将找到哪个元素。
    
    参数
    
    a - 要搜索的数组
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 。如果阵列中的所有元素都小于指定键的第一元件比所述键时，或a.length的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
  - binarySearch
```
public static int binarySearch(short[] a,
                               int fromIndex,
                               int toIndex,
                               short key)
```
    使用二进制搜索算法搜索指定值的指定数组的短整型范围。在进行此调用之前，范围必须按照sort(short[], int, int)方法进行排序。如果没有排序，结果是未定义的。如果范围包含具有指定值的多个元素，则不能保证将找到哪个元素。
    
    参数
    
    a - 要搜索的数组
    
    fromIndex - 要搜索的第一个元素（包括）的索引
    
    toIndex - 要搜索的最后一个元素（排他）的索引
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在指定范围内的数组中; 否则， (-(insertion point) - 1) 。如果在范围内的所有元素都小于指定的键在比所述键时，或toIndex的范围中的第一个元素的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 or toIndex > a.length
    
    从以下版本开始：
    
    1.6
  - binarySearch
```
public static int binarySearch(char[] a,
                               char key)
```
    使用二进制搜索算法搜索指定数组的指定值。在进行此调用之前，必须对数组进行排序（如sort(char[])方法）。如果没有排序，结果是未定义的。如果数组包含具有指定值的多个元素，则不能保证将找到哪个元素。
    
    参数
    
    a - 要搜索的数组
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 。如果阵列中的所有元素都小于指定键的第一元件比所述键时，或a.length的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
  - binarySearch
```
public static int binarySearch(char[] a,
                               int fromIndex,
                               int toIndex,
                               char key)
```
    使用二分搜索算法搜索指定值的指定数组的范围。在进行此呼叫之前，范围必须按照sort(char[], int, int)方法进行排序。如果没有排序，结果是未定义的。如果范围包含具有指定值的多个元素，则不能保证将找到哪个元素。
    
    参数
    
    a - 要搜索的数组
    
    fromIndex - 要搜索的第一个元素（包括）的索引
    
    toIndex - 要搜索的最后一个元素（排他）的索引
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在指定范围内的数组中; 否则， (-(insertion point) - 1) 。如果在范围内的所有元素都小于指定的键在比所述键时，或toIndex的范围中的第一个元素的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 or toIndex > a.length
    
    从以下版本开始：
    
    1.6
  - binarySearch
```
public static int binarySearch(byte[] a,
                               byte key)
```
    使用二进制搜索算法搜索指定值的指定字节数组。在进行此调用之前，数组必须按照sort(byte[])方法进行排序。如果没有排序，结果是未定义的。如果数组包含具有指定值的多个元素，则不能保证将找到哪个元素。
    
    参数
    
    a - 要搜索的数组
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 。如果阵列中的所有元素都小于指定键的第一元件比所述键时，或a.length的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
  - binarySearch
```
public static int binarySearch(byte[] a,
                               int fromIndex,
                               int toIndex,
                               byte key)
```
    使用二进制搜索算法搜索指定值的指定字节数组的范围。在进行此呼叫之前，范围必须按照sort(byte[], int, int)方法进行排序。如果没有排序，结果是未定义的。如果范围包含具有指定值的多个元素，则不能保证将找到哪个元素。
    
    参数
    
    a - 要搜索的数组
    
    fromIndex - 要搜索的第一个元素（包括）的索引
    
    toIndex - 要搜索的最后一个元素（排他）的索引
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在指定范围内的数组中; 否则， (-(insertion point) - 1) 。如果在范围内的所有元素都小于指定的键在比所述键时，或toIndex的范围中的第一个元素的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 or toIndex > a.length
    
    从以下版本开始：
    
    1.6
  - binarySearch
```
public static int binarySearch(double[] a,
                               double key)
```
    使用二进制搜索算法搜索指定值的指定数组的双精度值。在进行此调用之前，必须对数组进行排序（按照sort(double[])方法）。如果没有排序，结果是未定义的。如果数组包含具有指定值的多个元素，则不能保证将找到哪个元素。该方法认为所有的NaN值都是相等的。
    
    参数
    
    a - 要搜索的数组
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 。如果阵列中的所有元素都小于指定键的第一元件比所述键时，或a.length的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
  - binarySearch
```
public static int binarySearch(double[] a,
                               int fromIndex,
                               int toIndex,
                               double key)
```
    使用二分搜索算法搜索指定值的指定数组的双精度范围。在进行此呼叫之前，范围必须按照sort(double[], int, int)方法进行排序。如果没有排序，结果是未定义的。如果范围包含具有指定值的多个元素，则不能保证将找到哪个元素。该方法认为所有的NaN值都是相等的。
    
    参数
    
    a - 要搜索的数组
    
    fromIndex - 要搜索的第一个元素（包括）的索引
    
    toIndex - 要搜索的最后一个元素（排他）的索引
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在指定范围内的数组中; 否则， (-(insertion point) - 1) 。如果在范围内的所有元素都小于指定的键在比所述键时，或toIndex的范围中的第一个元素的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 or toIndex > a.length
    
    从以下版本开始：
    
    1.6
  - binarySearch
```
public static int binarySearch(float[] a,
                               float key)
```
    使用二叉搜索算法搜索指定数组的浮点数。在进行此调用之前，数组必须按照sort(float[])方法进行排序。如果没有排序，结果是未定义的。如果数组包含具有指定值的多个元素，则不能保证将找到哪个元素。该方法认为所有的NaN值都是相等的。
    
    参数
    
    a - 要搜索的数组
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 。如果阵列中的所有元素都小于指定键的第一元件比所述键时，或a.length的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
  - binarySearch
```
public static int binarySearch(float[] a,
                               int fromIndex,
                               int toIndex,
                               float key)
```
    使用二分搜索算法搜索指定数组的浮点数范围。在进行此呼叫之前，范围必须按照sort(float[], int, int)方法进行排序。如果没有排序，结果是未定义的。如果范围包含具有指定值的多个元素，则不能保证将找到哪个元素。该方法认为所有的NaN值都是相等的。
    
    参数
    
    a - 要搜索的数组
    
    fromIndex - 要搜索的第一个元素（包括）的索引
    
    toIndex - 要搜索的最后一个元素（排他）的索引
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在指定范围内的数组中; 否则， (-(insertion point) - 1) 。如果在范围内的所有元素都小于指定的键在比所述键时，或toIndex的范围中的第一个元素的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 or toIndex > a.length
    
    从以下版本开始：
    
    1.6
  - binarySearch
```
public static int binarySearch(Object[] a,
                               Object key)
```
    使用二叉搜索算法搜索指定对象的指定数组。所述阵列必须根据被按升序排列natural ordering元素（如由sort(Object[])方法）之前使该呼叫。如果没有排序，结果是未定义的。（如果数组包含不相互比较的元素（例如字符串和整数），则不能根据其元素的自然排序进行排序，因此结果未定义。）如果数组包含等于指定对象的多个元素，不能保证会找到哪一个。
    
    参数
    
    a - 要搜索的数组
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 。如果阵列中的所有元素都小于指定键的第一元件比所述键时，或a.length的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
    
    异常
    
    ClassCastException - 如果搜索关键字与数组的元素无法比较。
  - binarySearch
```
public static int binarySearch(Object[] a,
                               int fromIndex,
                               int toIndex,
                               Object key)
```
    使用二进制搜索算法搜索指定对象的指定数组的范围。的范围必须根据被按升序排列natural ordering元素（如由sort(Object[], int, int)方法）之前使该呼叫。如果没有排序，结果是未定义的。（如果范围包含不相互比较的元素（例如字符串和整数），则不能根据其元素的自然排序进行排序，因此结果未定义。）如果范围包含等于指定对象的多个元素，不能保证会找到哪一个。
    
    参数
    
    a - 要搜索的数组
    
    fromIndex - 要搜索的第一个元素（包括）的索引
    
    toIndex - 要搜索的最后一个元素（排他）的索引
    
    key - 要搜索的值
    
    结果
    
    搜索键的索引，如果它包含在指定范围内的数组中; 否则， (-(insertion point) - 1) 。如果在范围内的所有元素都小于指定的键在比所述键时，或toIndex的范围中的第一个元素的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
    
    异常
    
    ClassCastException - 如果搜索关键字与指定范围内的数组的元素不可比较。
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 or toIndex > a.length
    
    从以下版本开始：
    
    1.6
  - binarySearch
```
public static <T> int binarySearch(T[] a,
                                   T key,
                                   Comparator<? super T> c)
```
    使用二叉搜索算法搜索指定对象的指定数组。在进行此调用之前，数组必须按照指定的比较器（如sort(T[], Comparator)方法）按升序排列。如果没有排序，结果是未定义的。如果数组包含与指定对象相等的多个元素，则不能保证将找到哪个元素。
    
    参数类型
    
    T - 数组中对象的类
    
    参数
    
    a - 要搜索的数组
    
    key - 要搜索的值
    
    c - 排列数组的比较器。 A null值表示应使用元素' natural ordering '。
    
    结果
    
    搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 。如果阵列中的所有元素都小于指定键的第一元件比所述键时，或a.length的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
    
    异常
    
    ClassCastException - 如果数组包含使用指定的比较器不 相互比较的元素，或者搜索关键字与使用该比较器的数组的元素不可比较。
  - binarySearch
```
public static <T> int binarySearch(T[] a,
                                   int fromIndex,
                                   int toIndex,
                                   T key,
                                   Comparator<? super T> c)
```
    使用二进制搜索算法搜索指定对象的指定数组的范围。在进行此呼叫之前，范围必须根据指定的比较器（如sort(T[], int, int, Comparator)方法）按升序排序。如果没有排序，结果是未定义的。如果范围包含等于指定对象的多个元素，则不能保证将找到哪个元素。
    
    参数类型
    
    T - 数组中对象的类
    
    参数
    
    a - 要搜索的数组
    
    fromIndex - 要搜索的第一个元素（含）的索引
    
    toIndex - 要搜索的最后一个元素（排他）的索引
    
    key - 要搜索的值
    
    c - 排列数组的比较器。 A null值表示应使用元素' natural ordering '。
    
    结果
    
    搜索键的索引，如果它包含在指定范围内的数组中; 否则， (-(insertion point) - 1) 。如果在范围内的所有元素都小于指定的键在比所述键时，或toIndex的范围中的第一个元素的索引： 插入点被定义为将键插入到阵列的点。请注意，这确保当且仅当找到该键时返回值将为> = 0。
    
    异常
    
    ClassCastException - 如果范围包含使用指定的比较器不 相互比较的元素，或者搜索键与使用该比较器的范围内的元素不可比。
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 or toIndex > a.length
    
    从以下版本开始：
    
    1.6
  - equals
```
public static boolean equals(long[] a,
                             long[] a2)
```
    如果两个指定的longs数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null，则它们被认为是相等的 。
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要测试的其他数组的相等性
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(int[] a,
                             int[] a2)
```
    如果两个指定的int数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null，则它们被认为是相等的 。
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要测试的其他数组是否相等
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(short[] a,
                             short[] a2)
```
    如果两个指定的短数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null，则两个数组引用被认为是相等的 。
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要测试的其他数组是否相等
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(char[] a,
                             char[] a2)
```
    如果两个指定的字符数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null，则它们被认为是相等的 。
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要进行相等测试的另一个数组
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(byte[] a,
                             byte[] a2)
```
    如果两个指定的字节数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null，则它们被认为是相等的 。
    
    参数
    
    a - 要进行相等测试的一个数组
    
    a2 - 要测试的其他数组是否相等
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(boolean[] a,
                             boolean[] a2)
```
    如果两个指定的布尔数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两者都是null ，则两个数组引用被认为是相等的 。
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要测试的其他数组是否相等
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(double[] a,
                             double[] a2)
```
    如果两个指定的双精度数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null，则两个数组引用被认为是相等的 。
    如果以下情况，两个双打d1和d2被认为是相等的
```
  new Double(d1).equals(new Double(d2)) 
```
    （与==运算符不同，该方法认为NaN等于自身，0.0d不等于-0.0d））
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要测试的另一个数组是否相等
    
    结果
    
    true如果两个数组相等
    
    另请参见：
    
    Double.equals(Object)
  - equals
```
public static boolean equals(float[] a,
                             float[] a2)
```
    如果两个指定的浮动数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null，则它们被认为是相等的 。
    如下所示，两个浮标f1和f2被认为是相等的：
```
  new Float(f1).equals(new Float(f2)) 
```
    （与==运算符不同，此方法认为NaN等于自身，0.0f不等于-0.0f））
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要测试的其他数组是否相等
    
    结果
    
    true如果两个数组相等
    
    另请参见：
    
    Float.equals(Object)
  - equals
```
public static boolean equals(Object[] a,
                             Object[] a2)
```
    如果两个指定的对象数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。如果(e1==null ? e2==null : e1.equals(e2))，两个对象e1和e2被认为是相等的 。换句话说，如果两个数组在相同的顺序中包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null，则两个数组引用被认为是相等的 。
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要进行相等测试的另一个数组
    
    结果
    
    true如果两个数组相等
  - fill
```
public static void fill(long[] a,
                        long val)
```
    将指定的long值分配给指定的longs数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(long[] a,
                        int fromIndex,
                        int toIndex,
                        long val)
```
    将指定的long值分配给指定的longs数组的指定范围的每个元素。要填充的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，要填充的范围是空的。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要用指定值填充的最后一个元素（排他）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果是 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(int[] a,
                        int val)
```
    将指定的int值分配给指定的int数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(int[] a,
                        int fromIndex,
                        int toIndex,
                        int val)
```
    将指定的int值分配给指定的int数组的指定范围的每个元素。要填充的范围从索引fromIndex扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，要填充的范围是空的。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要用指定值填充的最后一个元素（排除）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(short[] a,
                        short val)
```
    将指定的短值分配给指定的短裤数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(short[] a,
                        int fromIndex,
                        int toIndex,
                        short val)
```
    将指定的短值分配给指定的短裤数组的指定范围的每个元素。要填充的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。（如果是fromIndex==toIndex ，要填充的范围是空的。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要用指定值填充的最后一个元素（排除）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(char[] a,
                        char val)
```
    将指定的char值分配给指定的char数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(char[] a,
                        int fromIndex,
                        int toIndex,
                        char val)
```
    将指定的char值分配给指定的char数组的指定范围的每个元素。要填补的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，要填充的范围是空的。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要用指定值填充的最后一个元素（排他）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(byte[] a,
                        byte val)
```
    将指定的字节值分配给指定字节数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(byte[] a,
                        int fromIndex,
                        int toIndex,
                        byte val)
```
    将指定的字节值分配给指定字节数组的指定范围的每个元素。待填写的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，要填充的范围是空的。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要用指定值填充的最后一个元素（排除）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(boolean[] a,
                        boolean val)
```
    将指定的布尔值分配给指定的布尔数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(boolean[] a,
                        int fromIndex,
                        int toIndex,
                        boolean val)
```
    将指定的布尔值分配给指定数组布尔值的指定范围的每个元素。要填补的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。（如果是fromIndex==toIndex ，要填充的范围是空的。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要用指定值填充的第一个元素（含）的索引
    
    toIndex - 要用指定值填充的最后一个元素（排他）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(double[] a,
                        double val)
```
    将指定的double值分配给指定的双精度数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(double[] a,
                        int fromIndex,
                        int toIndex,
                        double val)
```
    将指定的double值分配给指定的双精度数组范围的每个元素。要填充的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，要填充的范围是空的。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要用指定值填充的最后一个元素（排除）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果是 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(float[] a,
                        float val)
```
    将指定的float值分配给指定的浮点数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(float[] a,
                        int fromIndex,
                        int toIndex,
                        float val)
```
    将指定的浮点值分配给指定的浮点数组的指定范围的每个元素。要填充的范围从索引fromIndex扩展到索引toIndex ，排他。（如果是fromIndex==toIndex ，要填充的范围是空的。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要用指定值填充的最后一个元素（排除）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(Object[] a,
                        Object val)
```
    将指定的对象引用分配给指定的对象数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    ArrayStoreException - 如果指定的值不是可以存储在指定数组中的运行时类型
  - fill
```
public static void fill(Object[] a,
                        int fromIndex,
                        int toIndex,
                        Object val)
```
    将指定的对象引用分配给指定的对象数组的指定范围的每个元素。要填充的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，要填充的范围是空的。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要用指定值填充的最后一个元素（排除）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
    
    ArrayStoreException - 如果指定的值不是可以存储在指定数组中的运行时类型
  - copyOf
```
public static <T> T[] copyOf(T[] original,
                             int newLength)
```
    复制指定的数组，用空值截断或填充（如有必要），以便复制具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含null 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。结果数组与原始数组完全相同的类。
    
    参数类型
    
    T - 数组中对象的类
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，截断或填充空值以获取指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static <T,U> T[] copyOf(U[] original,
                               int newLength,
                               类<? extends T[]> newType)
```
    复制指定的数组，用空值截断或填充（如有必要），以便复制具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含null 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。最终的数组是newType 。
    
    参数类型
    
    U - 原始数组中对象的类
    
    T - 返回数组中对象的类
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    newType - 要返回的副本的类
    
    结果
    
    原始数组的副本，截断或填充空值以获取指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    ArrayStoreException - 如果从 original复制的元素不是可以存储在类别 newType的数组中的运行时类型
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static byte[] copyOf(byte[] original,
                            int newLength)
```
    复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含(byte)0 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，被截断或用零填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static short[] copyOf(short[] original,
                             int newLength)
```
    复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含(short)0 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，被截断或用零填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static int[] copyOf(int[] original,
                           int newLength)
```
    复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含0 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，被截断或用零填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static long[] copyOf(long[] original,
                            int newLength)
```
    复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含0L 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，被截断或用零填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static char[] copyOf(char[] original,
                            int newLength)
```
    复制指定的数组，截断或填充空字符（如有必要），以便复制具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含'\\u000' 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，截断或填充空字符以获取指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength是否定的
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static float[] copyOf(float[] original,
                             int newLength)
```
    复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含0f 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，被截断或用零填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static double[] copyOf(double[] original,
                              int newLength)
```
    复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含0d 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，被截断或用零填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static boolean[] copyOf(boolean[] original,
                               int newLength)
```
    复制指定的数组，截断或填充false （如有必要），以使副本具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含false 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，被截断或填充有假元素以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static <T> T[] copyOfRange(T[] original,
                                  int from,
                                  int to)
```
    将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。必须大于或等于from的范围（ to ）的最终指数可能大于original.length ，在这种情况下， null被放置在其索引大于或等于original.length - from的副本的所有元素中。返回的数组的长度将为to - from 。
    结果数组与原始数组完全相同的类。
    
    参数类型
    
    T - 数组中对象的类
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，排他。（该索引可能位于数组之外）
    
    结果
    
    一个包含原始数组的指定范围的新数组，用空值截断或填充以获取所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 from < 0或 from > original.length
    
    IllegalArgumentException - 如果是 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static <T,U> T[] copyOfRange(U[] original,
                                    int from,
                                    int to,
                                    类<? extends T[]> newType)
```
    将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。必须大于或等于from的范围（ to ）的最终指数可能大于original.length ，在这种情况下， null被放置在其索引大于或等于original.length - from的副本的所有元素中。返回的数组的长度将为to - from 。结果的数组是newType类。
    
    参数类型
    
    U - 原始数组中对象的类
    
    T - 返回数组中对象的类
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，排他。（该索引可能位于数组之外）
    
    newType - 要返回的副本的类
    
    结果
    
    一个包含原始数组的指定范围的新数组，用空值截断或填充以获取所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    ArrayStoreException - 如果从 original复制的元素不是可以存储在类别 newType的数组中的运行时类型。
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static byte[] copyOfRange(byte[] original,
                                 int from,
                                 int to)
```
    将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。必须大于或等于from的范围（ to ）的最终指数可能大于original.length ，在这种情况下(byte)0被放置在其索引大于或等于original.length - from的副本的所有元素中。返回的数组的长度将为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，排他。（该索引可能位于数组之外）
    
    结果
    
    一个包含原始数组的指定范围的新数组，用零截取或填充以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static short[] copyOfRange(short[] original,
                                  int from,
                                  int to)
```
    将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。范围（ to ）的最终索引（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， (short)0放在索引大于或等于original.length - from的副本的所有元素中。返回的数组的长度将为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，排他。（该索引可能位于数组之外）
    
    结果
    
    一个包含原始数组的指定范围的新数组，用零截取或填充以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static int[] copyOfRange(int[] original,
                                int from,
                                int to)
```
    将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。必须大于或等于from的范围（ to ）的最终指数可能大于original.length ，在这种情况下0被放置在其索引大于或等于original.length - from的副本的所有元素中。返回的数组的长度将为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，排他。（该索引可能位于数组之外）
    
    结果
    
    一个包含原始数组的指定范围的新数组，用零截取或填充以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static long[] copyOfRange(long[] original,
                                 int from,
                                 int to)
```
    将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。范围（ to ）的最终索引（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， 0L被放置在其索引大于或等于original.length - from的副本的所有元素中。返回的数组的长度将为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，排他。（该索引可能位于数组之外）
    
    结果
    
    一个包含原始数组的指定范围的新数组，用零截取或填充以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static char[] copyOfRange(char[] original,
                                 int from,
                                 int to)
```
    将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非是from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。范围（ to ）的最终指数（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， '\\u000'放在其索引大于或等于original.length - from的副本的所有元素中。返回的数组的长度将为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，排他。（该索引可能位于数组之外）
    
    结果
    
    一个包含原始数组的指定范围的新数组，被截断或填充有空字符以获取所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static float[] copyOfRange(float[] original,
                                  int from,
                                  int to)
```
    将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。范围（ to ）的最终指数（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， 0f放在其索引大于或等于original.length - from的副本的所有元素中。返回的数组的长度将为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，排他。（该索引可能位于数组之外）
    
    结果
    
    一个包含原始数组的指定范围的新数组，用零截取或填充以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static double[] copyOfRange(double[] original,
                                   int from,
                                   int to)
```
    将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非是from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。必须大于或等于from的范围（ to ）的最终索引可能大于original.length ，在这种情况下， 0d被放置在其索引大于或等于original.length - from的副本的所有元素中。返回数组的长度将为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，排他。（该索引可能位于数组之外）
    
    结果
    
    一个包含原始数组的指定范围的新数组，用零截取或填充以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static boolean[] copyOfRange(boolean[] original,
                                    int from,
                                    int to)
```
    将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。范围（ to ）的最终指数（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， false被放置在索引大于或等于original.length - from的副本的所有元素中。返回的数组的长度将为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，排他。（该索引可能位于数组之外）
    
    结果
    
    一个包含原始数组的指定范围的新数组，被截断或填充了假元素以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 from < 0或 from > original.length
    
    IllegalArgumentException - 如果是 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - asList
```
@SafeVarargs
public static <T> List<T> asList(T... a)
```
    返回由指定数组支持的固定大小的列表。（将返回的列表更改为“写入数组”。）该方法作为基于数组和基于集合的API之间的桥梁，与Collection.toArray()相结合。返回的列表是可序列化的，并实现RandomAccess 。
    此方法还提供了一种方便的方式来创建一个初始化为包含几个元素的固定大小的列表：
```
  List<String> stooges = Arrays.asList("Larry", "Moe", "Curly"); 
```
    参数类型
    
    T - 数组中对象的类
    
    参数
    
    a - 列表将被支持的数组
    
    结果
    
    指定数组的列表视图
  - hashCode
```
public static int hashCode(long[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个long阵列a和b这样Arrays.equals(a, b) ，也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Long个实例表示的a以相同顺序的元素。如果a是null ，则此方法返回0。
    
    参数
    
    a - 要计算的哈希值的数组
    
    结果
    
    一个基于内容的散列码为 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(int[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个非空的int阵列a和b等Arrays.equals(a, b) ，也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Integer个实例表示的a以相同顺序的元素。如果a为null ，则此方法返回0。
    
    参数
    
    a - 要计算的哈希值的数组
    
    结果
    
    一个基于内容的散列码为 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(short[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个short阵列a和b这样的Arrays.equals(a, b) ，也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Short个实例表示的a以相同顺序的元素。如果a为null ，则此方法返回0。
    
    参数
    
    a - 要计算的哈希值的数组
    
    结果
    
    一个基于内容的哈希码为 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(char[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个char阵列a和b等Arrays.equals(a, b) ，也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Character个实例表示的a以相同顺序的元素。如果a为null ，则此方法返回0。
    
    参数
    
    a - 要计算的哈希值的数组
    
    结果
    
    一个基于内容的哈希码为 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(byte[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个byte阵列a和b等Arrays.equals(a, b) ，也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Byte个实例表示的a以相同顺序的元素。如果a为null ，则此方法返回0。
    
    参数
    
    a - 要计算的哈希值的数组
    
    结果
    
    一个基于内容的哈希码为 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(boolean[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个boolean阵列a和b这样Arrays.equals(a, b) ，也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    此方法返回的值与通过在同一顺序中包含 Boolean表达a元素的88446024714736的一个List调用hashCode方法获得的值相同。如果a为null ，则此方法返回0。
    
    参数
    
    a - 要计算的哈希值的数组
    
    结果
    
    一个基于内容的散列码为 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(float[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个float阵列a和b等Arrays.equals(a, b) ，也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Float个实例表示的a以相同顺序的元素。如果a为null ，则此方法返回0。
    
    参数
    
    a - 要计算的哈希值的数组
    
    结果
    
    一个基于内容的散列码为 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(double[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个double a阵列和b，使得Arrays.equals(a, b)，它也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Double个实例表示的a以相同顺序的元素。如果a为null ，则此方法返回0。
    
    参数
    
    a - 要计算的哈希值的数组
    
    结果
    
    一个基于内容的哈希码为 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(Object[] a)
```
    根据指定数组的内容返回哈希码。如果数组包含其他数组作为元素，则哈希码基于它们的身份而不是其内容。因此，可以直接或间接通过一个或多个数组级别将数组本身作为元素调用此方法。
    对于任何两个阵列a和b等Arrays.equals(a, b) ，也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    
    通过此方法返回的值等于将由Arrays.asList(a).hashCode()被返回，除非a null是，在这种情况下是0返回的值。
    
    参数
    
    a - 要计算的基于内容的哈希码的数组
    
    结果
    
    一个基于内容的散列码为 a
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    deepHashCode(Object[])
  - deepHashCode
```
public static int deepHashCode(Object[] a)
```
    根据指定数组的“深度内容”返回哈希码。如果数组包含其他数组作为元素，那么哈希码就是基于它们的内容，等等，无穷无尽。因此，通过一个或多个级别的数组直接或间接地将自身作为元素的数组调用此方法是不可接受的。这种调用的行为是未定义的。
    对于任何两个阵列a和b等Arrays.deepEquals(a, b) ，也是Arrays.deepHashCode(a) == Arrays.deepHashCode(b)的情况。
    
    通过此方法返回的值的计算是类似于由返回的值的List.hashCode()包含相同的元素如a以相同的顺序在列表上，有一点不同：如果一个元素的a e本身是一个阵列，其散列代码不是通过调用e.hashCode()计算的，而是通过调用Arrays.hashCode(e)的适当重载（如果e是原始类型的数组），或者通过递归调用Arrays.deepHashCode(e)，如果e是引用类型的数组。如果a为null ，则此方法返回0。
    
    参数
    
    a - 其基于深度内容的哈希码计算的阵列
    
    结果
    
    一个基于深度内容的哈希码为 a
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    hashCode(Object[])
  - deepEquals
```
public static boolean deepEquals(Object[] a1,
                                 Object[] a2)
```
    如果两个指定的数组彼此深度相等 ，则返回true 。与equals(Object[],Object[])方法不同，该方法适用于任意深度的嵌套数组。
    如果两者都是null ，或者如果它们是指包含相同数量的元素的数组，并且两个数组中所有对应的元素对都相等，则两个数组引用被认为是相当相等的。
    
    如果以下任一条件成立 ，两个可能的null元素e1和e2都是相当的：
    - e1和e2都是对象引用类型的数组，而Arrays.deepEquals(e1, e2) would return true
    - e1和e2是相同基元类型的数组，Arrays.equals(e1, e2)的适当重载将返回true。
    - e1 == e2
    - e1.equals(e2)将返回true。
    请注意，此定义允许任何深度的null元素。
    如果任一指定的数组通过一个或多个数组级别直接或间接包含自身作为元素，则此方法的行为是未定义的。
    参数
    
    a1 - 要测试相等的一个数组
    
    a2 - 要测试的其他数组是否相等
    
    结果
    
    true如果两个数组相等
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    equals(Object[],Object[]) ， Objects.deepEquals(Object, Object)
  - toString
```
public static String toString(long[] a)
```
    返回指定数组的内容的字符串表示形式。字符串表示由数组元素的列表组成，括在方括号（ "[]" ）中。相邻的元素由字符", " （逗号后跟一个空格）分隔开。元素被转换为字符串由String.valueOf(long)。 返回"null"如果a是null。
    
    参数
    
    a - 要返回的字符串表示形式的数组
    
    结果
    
    一个字符串表示 a
    
    从以下版本开始：
    
    1.5
  - toString
```
public static String toString(int[] a)
```
    返回指定数组的内容的字符串表示形式。字符串表示由数组元素的列表组成，括在方括号（ "[]" ）中。相邻的元素由字符", "分隔（逗号后跟一个空格）。元素被转换为字符串由String.valueOf(int)。 返回"null"如果a是null。
    
    参数
    
    a - 要返回其字符串表示形式的数组
    
    结果
    
    一个字符串表示 a
    
    从以下版本开始：
    
    1.5
  - toString
```
public static String toString(short[] a)
```
    返回指定数组的内容的字符串表示形式。字符串表示由数组元素的列表组成，括在方括号（ "[]" ）中。相邻的元素由字符", " （逗号后跟一个空格）分隔开。元素被转换为字符串由String.valueOf(short)。 返回"null"如果a是null。
    
    参数
    
    a - 要返回的字符串表示形式的数组
    
    结果
    
    一个字符串表示法 a
    
    从以下版本开始：
    
    1.5
  - toString
```
public static String toString(char[] a)
```
    返回指定数组的内容的字符串表示形式。字符串表示由数组元素的列表组成，括在方括号（ "[]" ）中。相邻的元素由字符", " （逗号后跟一个空格）分隔开。元素将转换为字符串，如String.valueOf(char) 。返回"null"如果a是null。
    
    参数
    
    a - 要返回的字符串表示形式的数组
    
    结果
    
    一个字符串表示 a
    
    从以下版本开始：
    
    1.5
  - toString
```
public static String toString(byte[] a)
```
    返回指定数组的内容的字符串表示形式。字符串表示由数组元素的列表组成，括在方括号（ "[]" ）中。相邻的元素由字符", "分隔（逗号后跟一个空格）。元素被转换为字符串由String.valueOf(byte)。 返回"null"如果a是null。
    
    参数
    
    a - 要返回其字符串表示形式的数组
    
    结果
    
    一个字符串表示 a
    
    从以下版本开始：
    
    1.5
  - toString
```
public static String toString(boolean[] a)
```
    返回指定数组的内容的字符串表示形式。字符串表示由数组元素的列表组成，括在方括号（ "[]" ）中。相邻的元素由字符", "分隔（逗号后跟一个空格）。元素将转换为字符串，如String.valueOf(boolean) 。返回"null"如果a是null。
    
    参数
    
    a - 要返回的字符串表示形式的数组
    
    结果
    
    一个字符串表示形式为 a
    
    从以下版本开始：
    
    1.5
  - toString
```
public static String toString(float[] a)
```
    返回指定数组的内容的字符串表示形式。字符串表示由数组元素的列表组成，括在方括号（ "[]" ）中。相邻的元素由字符", " （逗号后跟一个空格）分隔开。元素被转换为字符串由String.valueOf(float)。 返回"null"如果a是null。
    
    参数
    
    a - 要返回的字符串表示形式的数组
    
    结果
    
    一个字符串表示形式为 a
    
    从以下版本开始：
    
    1.5
  - toString
```
public static String toString(double[] a)
```
    返回指定数组的内容的字符串表示形式。字符串表示由数组元素的列表组成，括在方括号（ "[]" ）中。相邻的元素由字符", "分隔（逗号后跟一个空格）。元素转换为字符串，如String.valueOf(double) 。返回"null"如果a是null。
    
    参数
    
    a - 要返回的字符串表示形式的数组
    
    结果
    
    一个字符串表示 a
    
    从以下版本开始：
    
    1.5
  - toString
```
public static String toString(Object[] a)
```
    返回指定数组的内容的字符串表示形式。如果数组包含其它数组作为元件，它们被转换为字符串Object.toString()从Object继承的方法，其描述了他们的身份，而不是其内容。
    通过此方法返回的值等于将由Arrays.asList(a).toString()被返回，除非a null是，在这种情况下是"null"返回的值。
    
    参数
    
    a - 要返回的字符串表示形式的数组
    
    结果
    
    一个字符串表示形式为 a
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    deepToString(Object[])
  - deepToString
```
public static String deepToString(Object[] a)
```
    返回指定数组的“深度内容”的字符串表示形式。如果数组包含其他数组作为元素，则字符串表示包含其内容等等。此方法用于将多维数组转换为字符串。
    字符串表示由数组元素的列表组成，括在方括号（ "[]" ）中。相邻的元素由字符", " （逗号后跟一个空格）分隔开。元件由String.valueOf(Object)转换为字符串，除非它们本身阵列。
    
    如果一个元素e是一个基本类型的阵列，它通过调用的Arrays.toString(e)适当重载转换为字符串作为。如果元素e是引用类型的数组，则通过递归调用此方法将其转换为字符串。
    
    为了避免无限递归，如果指定的数组包含自身作为元素，或者通过一个或多个数组级别包含对其自身的间接引用，则将自引用转换为字符串"[...]" 。例如，仅包含对其自身的引用的数组将被呈现为"[[...]]" 。
    
    如果指定数组是null此方法返回"null"。
    
    参数
    
    a - 要返回的字符串表示形式的数组
    
    结果
    
    一个字符串表示形式为 a
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    toString(Object[])
  - setAll
```
public static <T> void setAll(T[] array,
                              IntFunction<? extends T> generator)
```
    使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
    如果生成器函数引发异常，则将其转发给调用者，并将数组置于不确定状态。
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - parallelSetAll
```
public static <T> void parallelSetAll(T[] array,
                                      IntFunction<? extends T> generator)
```
    使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
    如果发电机功能抛出异常，一个未经检查的异常是从抛出parallelSetAll和阵列保持处于不确定状态。
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - setAll
```
public static void setAll(int[] array,
                          IntUnaryOperator generator)
```
    使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
    如果生成器函数引发异常，则将其转发给调用者，并将数组置于不确定状态。
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(int[] array,
                                  IntUnaryOperator generator)
```
    使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
    如果生成器函数引发异常，则会从parallelSetAll抛出未检查的异常，并将数组置于不确定状态。
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - setAll
```
public static void setAll(long[] array,
                          IntToLongFunction generator)
```
    使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
    如果生成器函数引发异常，则将其转发给调用者，并将数组置于不确定状态。
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(long[] array,
                                  IntToLongFunction generator)
```
    使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
    如果生成器函数引发异常，则会从parallelSetAll抛出未检查的异常，并将数组置于不确定状态。
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - setAll
```
public static void setAll(double[] array,
                          IntToDoubleFunction generator)
```
    使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
    如果生成器函数引发异常，则将其转发给调用者，并将数组置于不确定状态。
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(double[] array,
                                  IntToDoubleFunction generator)
```
    使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
    如果生成器函数引发异常，则会从parallelSetAll抛出未检查的异常，并且数组处于不确定状态。
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置的期望值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - spliterator
```
public static <T> Spliterator<T> spliterator(T[] array)
```
    返回Spliterator覆盖所有指定数组。
    该报告spliterator Spliterator.SIZED ， Spliterator.SUBSIZED ， Spliterator.ORDERED和Spliterator.IMMUTABLE 。
    
    参数类型
    
    T - 元素的类型
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    结果
    
    数组元素的分割器
    
    从以下版本开始：
    
    1.8
  - spliterator
```
public static <T> Spliterator<T> spliterator(T[] array,
                                             int startInclusive,
                                             int endExclusive)
```
    返回Spliterator覆盖指定数组的指定范围内。
    该报告spliterator Spliterator.SIZED ， Spliterator.SUBSIZED ， Spliterator.ORDERED和Spliterator.IMMUTABLE 。
    
    参数类型
    
    T - 元素的类型
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引紧随上一个索引覆盖
    
    结果
    
    数组元素的分割器
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负数，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8
  - spliterator
```
public static Spliterator.OfInt spliterator(int[] array)
```
    返回Spliterator.OfInt覆盖所有指定数组。
    该报告spliterator Spliterator.SIZED ， Spliterator.SUBSIZED ， Spliterator.ORDERED和Spliterator.IMMUTABLE 。
    
    参数
    
    array - 假定在使用期间 array的数组
    
    结果
    
    数组元素的分割器
    
    从以下版本开始：
    
    1.8
  - spliterator
```
public static Spliterator.OfInt spliterator(int[] array,
                                            int startInclusive,
                                            int endExclusive)
```
    返回Spliterator.OfInt覆盖指定数组的指定范围内。
    该报告spliterator Spliterator.SIZED ， Spliterator.SUBSIZED ， Spliterator.ORDERED和Spliterator.IMMUTABLE 。
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    数组元素的分割器
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负数，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8
  - spliterator
```
public static Spliterator.OfLong spliterator(long[] array)
```
    返回Spliterator.OfLong覆盖所有指定数组。
    该报告spliterator Spliterator.SIZED ， Spliterator.SUBSIZED ， Spliterator.ORDERED和Spliterator.IMMUTABLE 。
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    结果
    
    阵列元素的拼接器
    
    从以下版本开始：
    
    1.8
  - spliterator
```
public static Spliterator.OfLong spliterator(long[] array,
                                             int startInclusive,
                                             int endExclusive)
```
    返回Spliterator.OfLong覆盖指定数组的指定范围内。
    该报告spliterator Spliterator.SIZED ， Spliterator.SUBSIZED ， Spliterator.ORDERED和Spliterator.IMMUTABLE 。
    
    参数
    
    array - 假定在使用期间 array的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    数组元素的分割器
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负数，则 endExclusive小于 startInclusive ，或 endExclusive大于阵列大小
    
    从以下版本开始：
    
    1.8
  - spliterator
```
public static Spliterator.OfDouble spliterator(double[] array)
```
    返回Spliterator.OfDouble覆盖所有指定数组。
    该报告spliterator Spliterator.SIZED ， Spliterator.SUBSIZED ， Spliterator.ORDERED和Spliterator.IMMUTABLE 。
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    结果
    
    数组元素的分割器
    
    从以下版本开始：
    
    1.8
  - spliterator
```
public static Spliterator.OfDouble spliterator(double[] array,
                                               int startInclusive,
                                               int endExclusive)
```
    返回Spliterator.OfDouble覆盖指定数组的指定范围内。
    该报告spliterator Spliterator.SIZED ， Spliterator.SUBSIZED ， Spliterator.ORDERED和Spliterator.IMMUTABLE 。
    
    参数
    
    array - 假定在使用期间 array的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    数组元素的分割器
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负数，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8
  - stream
```
public static <T> Stream<T> stream(T[] array)
```
    返回顺序Stream与指定的数组作为源。
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    结果
    
    一个 Stream的阵列
    
    从以下版本开始：
    
    1.8
  - stream
```
public static <T> Stream<T> stream(T[] array,
                                   int startInclusive,
                                   int endExclusive)
```
    返回顺序Stream与指定的数组作为源的指定范围。
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    一个 Stream的数组范围
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负数，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8
  - stream
```
public static IntStream stream(int[] array)
```
    返回顺序IntStream与指定的数组作为源。
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    结果
    
    一个 IntStream的数组
    
    从以下版本开始：
    
    1.8
  - stream
```
public static IntStream stream(int[] array,
                               int startInclusive,
                               int endExclusive)
```
    返回顺序IntStream与指定的数组作为源的指定范围。
    
    参数
    
    array - 假定在使用期间 array的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    一个 IntStream的阵列范围
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负数，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8
  - stream
```
public static LongStream stream(long[] array)
```
    返回顺序LongStream与指定的数组作为源。
    
    参数
    
    array - 假定在使用期间 array的数组
    
    结果
    
    一个 LongStream的阵列
    
    从以下版本开始：
    
    1.8
  - stream
```
public static LongStream stream(long[] array,
                                int startInclusive,
                                int endExclusive)
```
    返回顺序LongStream与指定的数组作为源的指定范围。
    
    参数
    
    array - 假定在使用期间 array的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    一个 LongStream的数组范围
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负数，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8
  - stream
```
public static DoubleStream stream(double[] array)
```
    返回顺序DoubleStream与指定的数组作为源。
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    结果
    
    一个 DoubleStream的数组
    
    从以下版本开始：
    
    1.8
  - stream
```
public static DoubleStream stream(double[] array,
                                  int startInclusive,
                                  int endExclusive)
```
    返回顺序DoubleStream与指定的数组作为源的指定范围。
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    一个 DoubleStream的阵列范围
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负数，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class Arrays

方法摘要

Methods inherited from class java.lang.Object

方法详细信息

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

sort

sort

sort

sort

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

equals

equals

equals

equals

equals

equals

equals

equals

equals

fill

fill

fill

fill

fill