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

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

这个类是Java Collections Framework的成员。

从以下版本开始：

1.2

方法摘要

所有方法静态方法具体的方法
Modifier and Type	方法	描述
`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(short[] a, int fromIndex, int toIndex, short key)`	使用二进制搜索算法搜索指定值的指定数组的短整型范围。
`static int`	`binarySearch(short[] a, short key)`	使用二进制搜索算法搜索指定值的指定数组的指定值。
`static int`	`binarySearch(Object[] a, int fromIndex, int toIndex, Object key)`	使用二进制搜索算法搜索指定对象的指定数组的范围。
`static int`	`binarySearch(Object[] a, Object 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 int`	`compare(boolean[] a, boolean[] b)`	`boolean`字典顺序比较两个 `boolean`阵列。
`static int`	`compare(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)`	比较两个 `boolean`阵列在 `boolean`指定的范围。
`static int`	`compare(byte[] a, byte[] b)`	`byte`字典顺序比较两个 `byte`阵列。
`static int`	`compare(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	比较两个 `byte`阵列在 `byte`指定的范围。
`static int`	`compare(char[] a, char[] b)`	`char`字典顺序比较两个 `char`阵列。
`static int`	`compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)`	比较两个 `char`阵列在字典上超过指定的范围。
`static int`	`compare(double[] a, double[] b)`	`double`字典顺序比较两个 `double`阵列。
`static int`	`compare(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)`	比较两个 `double`阵列在指定范围内的字典。
`static int`	`compare(float[] a, float[] b)`	`float`字典顺序比较两个 `float`阵列。
`static int`	`compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)`	比较两个 `float`阵列在字典上超过指定的范围。
`static int`	`compare(int[] a, int[] b)`	`int`字典顺序比较两个 `int`阵列。
`static int`	`compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	比较两个 `int`阵列在字典上超过指定的范围。
`static int`	`compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	比较两个 `long`阵列在 `long`指定的范围。
`static int`	`compare(long[] a, long[] b)`	`long`字典顺序比较两个 `long`阵列。
`static int`	`compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	比较两个 `short`阵列在字典上超过指定的范围。
`static int`	`compare(short[] a, short[] b)`	`short`字典顺序比较两个 `short`阵列。
`static <T extends Comparable<? super T>> int`	`compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)`	比较两个 `Object`阵列在 `Object`指定的范围。
`static <T> int`	`compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)`	比较两个 `Object`阵列在 `Object`指定的范围。
`static <T extends Comparable<? super T>> int`	`compare(T[] a, T[] b)`	比较两个 `Object`阵列，可比较的元素，按字典顺序。
`static <T> int`	`compare(T[] a, T[] b, Comparator<? super T> cmp)`	比较两个 `Object`阵列，使用指定的比较器进行字典比对。
`static int`	`compareUnsigned(byte[] a, byte[] b)`	比较两个 `byte`阵列的字典，数字处理元素为无符号。
`static int`	`compareUnsigned(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	比较两个 `byte`数组在指定范围内，数字处理元素为无符号。
`static int`	`compareUnsigned(int[] a, int[] b)`	比较两个 `int`阵列在 `int` ，数字处理元素为无符号。
`static int`	`compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	将两个 `int`阵列按 `int`顺序比较指定范围，将元素数字化处理为无符号。
`static int`	`compareUnsigned(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	比较两个 `long`阵列在指定的范围内，以数字方式处理元素为无符号。
`static int`	`compareUnsigned(long[] a, long[] b)`	比较两个 `long`阵列在 `long` ，数字处理元素为无符号。
`static int`	`compareUnsigned(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	将两个 `short`阵列按照 `short`顺序比较在指定范围内，将元素数字处理为无符号。
`static int`	`compareUnsigned(short[] a, short[] b)`	比较两个 `short`阵列的字典，数字处理元素为无符号。
`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, Class<? 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, Class<? 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(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)`	如果两个指定的布尔值数组在指定的范围内彼此相等，则返回true。
`static boolean`	`equals(byte[] a, byte[] a2)`	如果两个指定的字节数组彼此相等，则返回 `true` 。
`static boolean`	`equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	如果两个指定的字节数组（在指定范围内）彼此相等，则返回true。
`static boolean`	`equals(char[] a, char[] a2)`	如果两个指定的字符数组彼此相等，则返回 `true` 。
`static boolean`	`equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)`	如果两个指定的字符数组在指定范围内彼此相等，则返回true。
`static boolean`	`equals(double[] a, double[] a2)`	如果两个指定的双精度数组彼此相等，则返回 `true` 。
`static boolean`	`equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)`	如果指定范围内的两个指定的双精度数组彼此相等，则返回true。
`static boolean`	`equals(float[] a, float[] a2)`	如果两个指定的浮动数组彼此相等，则返回 `true` 。
`static boolean`	`equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)`	如果两个指定的浮点数在指定范围内相互相等，则返回true。
`static boolean`	`equals(int[] a, int[] a2)`	如果两个指定的int数组彼此相等，则返回 `true` 。
`static boolean`	`equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	如果两个指定的int数组在指定的范围内彼此相等，则返回true。
`static boolean`	`equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	如果指定范围内的两个指定的long数组彼此相等，则返回true。
`static boolean`	`equals(long[] a, long[] a2)`	如果两个指定的longs数组彼此相等，则返回 `true` 。
`static boolean`	`equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	如果两个指定的短整型数组在指定的范围内彼此相等，则返回true。
`static boolean`	`equals(short[] a, short[] a2)`	如果两个指定的短裤阵列彼此相等，则返回 `true` 。
`static boolean`	`equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)`	如果两个指定的对象数组在指定范围内彼此相等，则返回true。
`static boolean`	`equals(Object[] a, Object[] a2)`	如果两个指定的对象数组彼此相等，则返回 `true` 。
`static <T> boolean`	`equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)`	如果两个指定的对象数组在指定范围内彼此相等，则返回true。
`static <T> boolean`	`equals(T[] a, T[] a2, Comparator<? super T> cmp)`	如果两个指定的对象数组彼此相等，则返回 `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(short[] a, int fromIndex, int toIndex, short val)`	将指定的短值分配给指定的短裤数组的指定范围的每个元素。
`static void`	`fill(short[] a, short val)`	将指定的短值分配给指定的短裤数组的每个元素。
`static void`	`fill(Object[] a, int fromIndex, int toIndex, Object val)`	将指定的对象引用分配给指定的对象数组的指定范围的每个元素。
`static void`	`fill(Object[] a, Object 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(short[] a)`	根据指定数组的内容返回哈希码。
`static int`	`hashCode(Object[] a)`	根据指定数组的内容返回哈希码。
`static int`	`mismatch(boolean[] a, boolean[] b)`	查找并返回两个 `boolean`数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。
`static int`	`mismatch(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)`	查找并返回指定范围内两个 `boolean`数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。
`static int`	`mismatch(byte[] a, byte[] b)`	查找并返回两个 `byte`数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。
`static int`	`mismatch(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	查找并返回指定范围内两个 `byte`数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。
`static int`	`mismatch(char[] a, char[] b)`	查找并返回两个 `char`数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。
`static int`	`mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)`	查找并返回指定范围内两个 `char`数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。
`static int`	`mismatch(double[] a, double[] b)`	查找并返回两个 `double`数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。
`static int`	`mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)`	查找并返回指定范围内两个 `double`数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。
`static int`	`mismatch(float[] a, float[] b)`	查找并返回两个 `float`数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。
`static int`	`mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)`	查找并返回指定范围内的两个 `float`数组之间的第一个不匹配的相对索引，否则返回-1，如果没有发现不匹配。
`static int`	`mismatch(int[] a, int[] b)`	查找并返回两个 `int`数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。
`static int`	`mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	查找并返回指定范围内两个 `int`数组之间的第一个不匹配的相对索引，否则返回-1，如果没有发现不匹配。
`static int`	`mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	查找并返回指定范围内两个 `long`数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。
`static int`	`mismatch(long[] a, long[] b)`	查找并返回两个 `long`数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。
`static int`	`mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	查找并返回指定范围内两个 `short`数组之间的第一个不匹配的相对索引，否则返回-1，如果未发现不匹配。
`static int`	`mismatch(short[] a, short[] b)`	查找并返回两个 `short`数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。
`static int`	`mismatch(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)`	查找并返回指定范围内两个 `Object`数组之间的第一个不匹配的相对索引，否则返回-1，如果未发现不匹配。
`static int`	`mismatch(Object[] a, Object[] b)`	查找并返回两个 `Object`数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。
`static <T> int`	`mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)`	查找并返回指定范围内的两个 `Object`数组之间的第一个不匹配的相对索引，否则返回-1，如果未发现不匹配。
`static <T> int`	`mismatch(T[] a, T[] b, Comparator<? super T> cmp)`	查找并返回两个 `Object`数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。
`static void`	`parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)`	对于数组的给定子范围执行 `parallelPrefix(double[], DoubleBinaryOperator)` 。
`static void`	`parallelPrefix(double[] array, DoubleBinaryOperator op)`	使用提供的功能，并行地计算给定阵列的每个元素。
`static void`	`parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)`	对于数组的给定子范围执行 `parallelPrefix(int[], IntBinaryOperator)` 。
`static void`	`parallelPrefix(int[] array, IntBinaryOperator op)`	使用提供的功能，并行地计算给定阵列的每个元素。
`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, int fromIndex, int toIndex, BinaryOperator<T> op)`	对于数组的给定子范围执行 `parallelPrefix(Object[], BinaryOperator)` 。
`static <T> void`	`parallelPrefix(T[] array, BinaryOperator<T> op)`	使用提供的功能，并行地计算给定阵列的每个元素。
`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 extends Comparable<? super T>> void`	`parallelSort(T[] a, int fromIndex, int toIndex)`	根据其元素的27060729646982 ，将指定的对象数组的指定范围按升序排列。
`static <T> void`	`parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)`	根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序。
`static <T> void`	`parallelSort(T[] a, 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(short[] a)`	按照数字顺序排列指定的数组。
`static void`	`sort(short[] a, int fromIndex, int toIndex)`	按升序排列数组的指定范围。
`static void`	`sort(Object[] a)`	根据其元素的natural ordering按照升序排列指定的对象数组。
`static void`	`sort(Object[] a, int fromIndex, int toIndex)`	根据其元素的natural ordering按照升序排列指定数组对象的指定范围。
`static <T> void`	`sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)`	根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序。
`static <T> void`	`sort(T[] a, 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(short[] a)`	返回指定数组的内容的字符串表示形式。
`static String`	`toString(Object[] 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 ， 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(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 ， 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(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 - 要排序的第一个元素的索引（包括）
    
    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 - 要排序的第一个元素的索引（包括）
    
    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 ， 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 - 要排序的第一个元素的索引（包括）
    
    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 ， 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 ， 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 ， 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(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 - 要排序的第一个元素的索引（包括）
    
    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 ， fromIndex == toIndex排序的范围为空。
    所述<关系不能在所有浮点值提供一个总次序： -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 - 要排序的数组
    
    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抛出ClassCastException ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    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 ， fromIndex==toIndex排序的范围为空。）此范围内的所有元素必须实现Comparable接口。此外，该范围内的所有元素必须相互可比较 （即， e1.compareTo(e2)不能为ClassCastException中的任何元素e1和e2抛出ClassCastException ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    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抛出ClassCastException ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    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抛出ClassCastException ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    实现注意事项：这个实现是一个稳定的，自适应的，迭代的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抛出ClassCastException ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    实现注意事项：这个实现是一个稳定的，自适应的，迭代的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抛出ClassCastException ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    实现注意事项：这个实现是一个稳定的，自适应的，迭代的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 ， fromIndex==toIndex排序的范围为空。）范围中的所有元素必须通过指定的比较器相互比较（即c.compare(e1, e2)不得在任何元素e1和e2范围内抛出ClassCastException ）。
    这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
    
    实现注意事项：这个实现是一个稳定的，自适应的，迭代的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 ，则两个数组引用被认为是null 。
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要测试的另一个数组是否相等
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(long[] a,
                             int aFromIndex,
                             int aToIndex,
                             long[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果指定范围内的两个指定的long数组彼此相等，则返回true。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对相等。换句话说，如果两个数组在指定范围内以相同的顺序包含相同的元素，则它们是相等的。
    
    参数
    
    a - 要测试的第一个数组的相等性
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要测试的第二个数组平等
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    如果两个数组在指定的范围内相等， true
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一个阵列是 null
    
    从以下版本开始：
    
    9
  - equals
```
public static boolean equals(int[] a,
                             int[] a2)
```
    如果两个指定的int数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null则它们被认为是null 。
    
    参数
    
    a - 要进行相等测试的一个数组
    
    a2 - 要进行相等测试的另一个数组
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(int[] a,
                             int aFromIndex,
                             int aToIndex,
                             int[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果两个指定的int数组在指定的范围内彼此相等，则返回true。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对相等。换句话说，如果两个数组在指定范围内以相同的顺序包含相同的元素，则它们是相等的。
    
    参数
    
    a - 要测试的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要平等测试的第二个数组
    
    bFromIndex - 要测试的第二个数组中第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    true如果两个数组在指定范围内相等
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一个阵列是 null
    
    从以下版本开始：
    
    9
  - equals
```
public static boolean equals(short[] a,
                             short[] a2)
```
    如果两个指定的短裤阵列彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两者都是null ，则两个数组引用被认为是null 。
    
    参数
    
    a - 要进行相等测试的一个数组
    
    a2 - 要测试的其他数组相等
    
    结果
    
    如果两个数组相等， true
  - equals
```
public static boolean equals(short[] a,
                             int aFromIndex,
                             int aToIndex,
                             short[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果两个指定的短整型数组在指定的范围内彼此相等，则返回true。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对相等。换句话说，如果两个数组在指定范围内以相同的顺序包含相同的元素，则它们是相等的。
    
    参数
    
    a - 要测试的第一个数组是否相等
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要平等测试的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    true如果两个数组在指定范围内相等
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一个阵列是 null
    
    从以下版本开始：
    
    9
  - equals
```
public static boolean equals(char[] a,
                             char[] a2)
```
    如果两个指定的字符数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null则它们被认为是null 。
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要测试的其他数组是否相等
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(char[] a,
                             int aFromIndex,
                             int aToIndex,
                             char[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果两个指定的字符数组在指定范围内彼此相等，则返回true。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对相等。换句话说，如果两个数组在指定范围内以相同的顺序包含相同的元素，则它们是相等的。
    
    参数
    
    a - 要进行相等测试的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要测试的第二个数组平等
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    如果两个数组在指定的范围内相等， true
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或者如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或者如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组是 null
    
    从以下版本开始：
    
    9
  - equals
```
public static boolean equals(byte[] a,
                             byte[] a2)
```
    如果两个指定的字节数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null则它们被认为是null 。
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要测试的其他数组是否相等
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(byte[] a,
                             int aFromIndex,
                             int aToIndex,
                             byte[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果两个指定的字节数组（在指定范围内）彼此相等，则返回true。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对相等。换句话说，如果两个数组在指定范围内以相同的顺序包含相同的元素，则它们是相等的。
    
    参数
    
    a - 要测试的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要平等测试的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    如果两个数组在指定的范围内相等， true
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或者是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组是 null
    
    从以下版本开始：
    
    9
  - equals
```
public static boolean equals(boolean[] a,
                             boolean[] a2)
```
    如果两个指定的布尔数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null ，则两个数组引用被认为是null 。
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要进行相等测试的另一个数组
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(boolean[] a,
                             int aFromIndex,
                             int aToIndex,
                             boolean[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果两个指定的布尔值数组在指定的范围内彼此相等，则返回true。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对相等。换句话说，如果两个数组在指定范围内以相同的顺序包含相同的元素，则它们是相等的。
    
    参数
    
    a - 要测试的第一个数组的相等性
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要测试的第二个数组相等
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    如果两个数组在指定的范围内相等， true
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一个数组是 null
    
    从以下版本开始：
    
    9
  - equals
```
public static boolean equals(double[] a,
                             double[] a2)
```
    如果两个指定的双精度数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两者都是null ，则两个数组引用被认为是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(double[] a,
                             int aFromIndex,
                             int aToIndex,
                             double[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果指定范围内的两个指定的双精度数组彼此相等，则返回true。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对相等。换句话说，如果两个数组在指定范围内以相同的顺序包含相同的元素，则它们是相等的。
    
    d1和d2两个双打被认为是相等的：
    
    new Double(d1).equals(new Double(d2))
    （与==运算符不同，该方法认为NaN等于自身，0.0d不等于-0.0d））
    参数
    
    a - 要测试的第一个数组的相等性
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要平等测试的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中的最后一个元素的索引（独占）
    
    结果
    
    true如果两个数组在指定范围内相等
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或者如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一个阵列是 null
    
    从以下版本开始：
    
    9
    
    另请参见：
    
    Double.equals(Object)
  - equals
```
public static boolean equals(float[] a,
                             float[] a2)
```
    如果两个指定的浮动数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null ，这两个数组引用被认为是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(float[] a,
                             int aFromIndex,
                             int aToIndex,
                             float[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果两个指定的浮点数在指定范围内相互相等，则返回true。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对相等。换句话说，如果两个数组在指定范围内以相同的顺序包含相同的元素，则它们是相等的。
    
    如下所示，两个浮标f1和f2被认为是相等的：
    
    new Float(f1).equals(new Float(f2))
    （与==运算符不同，该方法认为NaN等于自身，0.0f不等于-0.0f））
    参数
    
    a - 要测试的第一个数组的相等性
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要平等测试的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    如果两个数组在指定范围内相等， true
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或者如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或者如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任何一个数组是 null
    
    从以下版本开始：
    
    9
    
    另请参见：
    
    Float.equals(Object)
  - equals
```
public static boolean equals(Object[] a,
                             Object[] a2)
```
    如果两个指定的对象数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。如果Objects.equals(e1, e2)则两个对象e1和e2被认为是相等的 。换句话说，如果两个数组在相同的顺序中包含相同的元素，则它们是相等的。另外，如果两者都是null ，则两个数组引用被认为是null 。
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要测试的其他数组是否相等
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(Object[] a,
                             int aFromIndex,
                             int aToIndex,
                             Object[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果两个指定的对象数组在指定范围内彼此相等，则返回true。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对相等。换句话说，如果两个数组在指定范围内以相同的顺序包含相同的元素，则它们是相等的。
    
    两个对象e1和e2被认为是如果相等 Objects.equals(e1, e2) 。
    
    参数
    
    a - 要测试的第一个数组相等
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要平等测试的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    如果两个数组在指定的范围内相等， true
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或者如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一个阵列是 null
    
    从以下版本开始：
    
    9
  - equals
```
public static <T> boolean equals(T[] a,
                                 T[] a2,
                                 Comparator<? super T> cmp)
```
    如果两个指定的对象数组彼此相等，则返回true 。
    如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组在相同的顺序中包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null则它们被认为是null 。
    
    两个对象e1和e2如果，考虑到指定的比较，被认为是相等 cmp.compare(e1, e2) == 0 。
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    a - 要测试相等的一个数组
    
    a2 - 要测试的其他数组是否相等
    
    cmp - 比较器来比较数组元素
    
    结果
    
    true如果两个数组相等
    
    异常
    
    NullPointerException - 如果比较器是 null
    
    从以下版本开始：
    
    9
  - equals
```
public static <T> boolean equals(T[] a,
                                 int aFromIndex,
                                 int aToIndex,
                                 T[] b,
                                 int bFromIndex,
                                 int bToIndex,
                                 Comparator<? super T> cmp)
```
    如果两个指定的对象数组在指定范围内彼此相等，则返回true。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对相等。换句话说，如果两个数组在指定范围内以相同的顺序包含相同的元素，则它们是相等的。
    
    两个对象e1和e2如果，考虑到指定的比较，被认为是相等 cmp.compare(e1, e2) == 0 。
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    a - 要测试的第一个数组的相等性
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要平等测试的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    cmp - 比较器来比较数组元素
    
    结果
    
    如果两个数组在指定的范围内相等， true
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任何一个阵列或比较器是 null
    
    从以下版本开始：
    
    9
  - 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到索引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到索引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,
                               Class<? 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.length 。 original[from]的值被放置在副本的初始元素中（除非是from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。范围（ to ）的最终指数（ to ）必须大于或等于from ，可能大于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,
                                    Class<? extends T[]> newType)
```
    将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非是from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。范围（ to ）的最终指数（ to ）必须大于或等于from ，可能大于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之间（ from ）。 original[from]的值被放置在副本的初始元素中（除非是from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。范围（ to ）的最终指数（ to ）必须大于或等于from ，可能大于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之间（ from ）。 original[from]的值被放置在副本的初始元素中（除非是from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。必须大于或等于from的范围（ to ）的最终索引可能大于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.length 。 original[from]的值被放置在副本的初始元素中（除非是from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。范围（ to ）的最终索引（ to ）必须大于或等于from ，可能大于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之间（ from ）。 original[from]的值被放置在副本的初始元素中（除非是from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。必须大于或等于from的范围（ to ）的最终索引可能大于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之间（ from ）。 original[from]的值被放入副本的初始元素（除非是from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。必须大于或等于from的范围（ to ）的最终索引可能大于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之间，包括0。 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之间，包括0。 original[from]的值被放置在副本的初始元素中（除非是from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。范围（ to ）的最终索引（ to ）必须大于或等于from ，可能大于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之间（ from ）。 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)的情况。
    此方法返回的值与通过在同一顺序中包含Integer表示a元素的a实例的List调用hashCode方法获得的值相同。如果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)的情况。
    此方法返回的值与通过在270607329292179中调用hashCode方法获得的值相同，该值为 270607329302174，其中包含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)的情况。
    此方法返回的值与通过在同一顺序中包含表示a元素的a实例的List的List调用hashCode方法获得的值相同。如果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)的情况。
    此方法返回的值与通过在List中调用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)的情况。
    此方法返回的值与通过在同一顺序中包含表示a元素的a实例的List的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)的情况。
    该方法返回的值与通过在同一顺序中包含表示a元素的a实例的List的270607329954208调用hashCode方法获得的值相同。如果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以相同的顺序，有一点不同：如果一个元素e的a本身是一个阵列，其散列代码是通过调用不计算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的Object.toString()方法转换为字符串，该方法描述了它们的身份而不是其内容。
    通过此方法返回的值等于将由要返回的值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)
```
    使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
    如果生成器函数引发异常，则将其转发给调用者，并将数组置于不确定状态。
    API Note:
    
    设置一个数组的子范围，使用生成函数来计算每个元素，可以写成如下：
    IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.apply(i));
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - parallelSetAll
```
public static <T> void parallelSetAll(T[] array,
                                      IntFunction<? extends T> generator)
```
    使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
    如果生成器函数引发异常，则从parallelSetAll抛出未检查的异常，并且数组处于不确定状态。
    API Note:
    
    使用生成函数来计算每个元素，并行设置数组的子范围，可以写成如下：
    IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.apply(i));
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - setAll
```
public static void setAll(int[] array,
                          IntUnaryOperator generator)
```
    使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
    如果生成器函数引发异常，则将其转发给调用者，并将数组置于不确定状态。
    API Note:
    
    设置一个数组的子范围，使用生成函数来计算每个元素，可以写成如下：
    IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.applyAsInt(i));
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(int[] array,
                                  IntUnaryOperator generator)
```
    使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
    如果生成器函数引发异常，则从parallelSetAll抛出未检查的异常，并将数组置于不确定状态。
    API Note:
    
    使用生成函数来计算每个元素，并行设置数组的子范围，可以写成如下：
    IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.applyAsInt(i));
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - setAll
```
public static void setAll(long[] array,
                          IntToLongFunction generator)
```
    使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
    如果生成器函数引发异常，则将其转发给调用者，并将数组置于不确定状态。
    API Note:
    
    设置一个数组的子范围，使用生成函数来计算每个元素，可以写成如下：
    IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.applyAsLong(i));
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(long[] array,
                                  IntToLongFunction generator)
```
    使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
    如果生成函数引发异常，则从parallelSetAll抛出未检查的异常，并且数组处于不确定状态。
    API Note:
    
    使用生成函数来计算每个元素，并行设置数组的子范围，可以写成如下：
    IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.applyAsLong(i));
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置所需值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - setAll
```
public static void setAll(double[] array,
                          IntToDoubleFunction generator)
```
    使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
    如果生成器函数引发异常，则将其转发给调用者，并将数组置于不确定状态。
    API Note:
    
    设置一个数组的子范围，使用生成函数来计算每个元素，可以写成如下：
    IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.applyAsDouble(i));
    
    参数
    
    array - 要初始化的数组
    
    generator - 接受索引并产生该位置的期望值的函数
    
    异常
    
    NullPointerException - 如果生成器为空
    
    从以下版本开始：
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(double[] array,
                                  IntToDoubleFunction generator)
```
    使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
    如果生成器函数引发异常，则从parallelSetAll抛出未检查的异常，并且数组处于不确定状态。
    API Note:
    
    使用生成函数来计算每个元素，并行设置数组的子范围，可以写成如下：
    IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.applyAsDouble(i));
    
    参数
    
    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 - 假定在使用过程中未修改的数组
    
    结果
    
    数组元素的分割器
    
    从以下版本开始：
    
    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 - 假定在使用过程中未修改的数组
    
    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 - 假定在使用过程中未修改的数组
    
    结果
    
    数组元素的分割器
    
    从以下版本开始：
    
    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 - 假定在使用过程中未修改的数组
    
    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 - 假定在使用过程中未修改的数组
    
    结果
    
    阵列元素的拼接器
    
    从以下版本开始：
    
    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 - 假定在使用过程中未修改的数组
    
    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 - 假定在使用期间未修改的数组
    
    结果
    
    数组元素的分割器
    
    从以下版本开始：
    
    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 - 假定在使用过程中未修改的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    数组元素的分割器
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负数，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8
  - stream
```
public static <T> Stream<T> stream(T[] array)
```
    返回具有指定数组的序列Stream作为其源。
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    array - 假定在使用过程中未修改的数组
    
    结果
    
    一个 Stream的阵列
    
    从以下版本开始：
    
    1.8
  - stream
```
public static <T> Stream<T> stream(T[] array,
                                   int startInclusive,
                                   int endExclusive)
```
    返回指定数组的指定范围作为源的顺序Stream 。
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    一个 Stream的阵列范围
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负数，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8
  - stream
```
public static IntStream stream(int[] array)
```
    返回具有指定数组的序列IntStream作为其源。
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    结果
    
    一个 IntStream的阵列
    
    从以下版本开始：
    
    1.8
  - stream
```
public static IntStream stream(int[] array,
                               int startInclusive,
                               int endExclusive)
```
    返回指定数组的指定范围作为源的连续IntStream 。
    
    参数
    
    array - 假定在使用过程中未修改的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    一个 IntStream的阵列范围
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8
  - stream
```
public static LongStream stream(long[] array)
```
    返回指定数组作为源的顺序LongStream 。
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    结果
    
    一个 LongStream的阵列
    
    从以下版本开始：
    
    1.8
  - stream
```
public static LongStream stream(long[] array,
                                int startInclusive,
                                int endExclusive)
```
    返回指定数组的指定范围作为其源的顺序LongStream 。
    
    参数
    
    array - 假定在使用过程中未修改的数组
    
    startInclusive - 涵盖的首个索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    一个 LongStream的阵列范围
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负数，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8
  - stream
```
public static DoubleStream stream(double[] array)
```
    返回指定数组作为源的顺序DoubleStream 。
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    结果
    
    一个 DoubleStream的阵列
    
    从以下版本开始：
    
    1.8
  - stream
```
public static DoubleStream stream(double[] array,
                                  int startInclusive,
                                  int endExclusive)
```
    返回指定数组的指定范围作为其源的顺序DoubleStream 。
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    startInclusive - 第一个涵盖的索引
    
    endExclusive - 索引立即通过最后一个索引覆盖
    
    结果
    
    一个 DoubleStream的阵列范围
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果 startInclusive为负，则 endExclusive小于 startInclusive ，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    1.8
  - compare
```
public static int compare(boolean[] a,
                          boolean[] b)
```
    boolean字典顺序比较两个boolean阵列。
    如果两个数组共享一个共同的前缀，那么词典比较是比较两个元素的结果，就像在Boolean.compare(boolean, boolean)中一样，在作为前缀长度的各个数组中的索引处。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(boolean[], boolean[]) ）
    
    A null阵列引用在字典上小于非null阵列引用。两个null数组引用被认为是相等的。
    
    该比较与equals一致，更具体地说对于阵列a和b ：
    
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    API Note:
    
    此方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Boolean.compare(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 要比较的第一个数组
    
    b - 第二个数组进行比较
    
    结果
    
    值0如果第一和第二个数组相等并且以相同的顺序包含相同的元素; 小于0的值，如果第一个数组按字典顺序小于第二个数组; 如果第一个数组的字典大于第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(boolean[] a,
                          int aFromIndex,
                          int aToIndex,
                          boolean[] b,
                          int bFromIndex,
                          int bToIndex)
```
    在指定范围内按字典顺序比较两个boolean阵列。
    如果两个数组在指定的范围内共享一个共同的前缀，那么词典比较就是比较两个元素的结果，就像Boolean.compare(boolean, boolean)一样，在作为前缀长度的相应数组内的相对索引处。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关常用和正确的前缀的定义，请参阅mismatch(boolean[], int, int, boolean[], int, int)。）
    
    该比较是一致equals ，更具体地以下适用于阵列a和b与指定的范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别地）：
    
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Boolean.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 要比较的第一个数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中最后一个元素的索引（独占）
    
    b - 第二个数组进行比较
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    值0如果超过指定范围的第一和第二个数组是相等的，并且以相同的顺序包含相同的元素; 小于0的值，如果超过指定范围，则第一个数组的字典数字小于第二个数组; 大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一阵列是 null
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(byte[] a,
                          byte[] b)
```
    byte字典顺序比较两个byte阵列。
    如果两个阵列共享一个共同的前缀，那么词典比较是比较两个元素的结果，就像在Byte.compare(byte, byte)中一样，在作为前缀长度的各个数组内的索引处。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(byte[], byte[]) ）
    
    A null阵列引用在字典上小于非null阵列引用。两个null数组引用被认为是相等的。
    
    该比较与equals一致，更具体地说，对于阵列a和b ，具体如下：
    
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    API Note:
    
    该方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Byte.compare(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 第一个要比较的数组
    
    b - 第二个数组进行比较
    
    结果
    
    值0如果第一和第二个数组相等并且包含相同的元素相同的顺序; 小于0的值，如果第一个数组的字典小于第二个数组; 如果第一个数组在0大于第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(byte[] a,
                          int aFromIndex,
                          int aToIndex,
                          byte[] b,
                          int bFromIndex,
                          int bToIndex)
```
    比较两个byte阵列在字典上超过指定的范围。
    如果两个数组在指定的范围内共享一个共同的前缀，那么词典比较就是比较两个元素的结果，如Byte.compare(byte, byte)那样，在作为前缀长度的相应数组内的相对索引处。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(byte[], int, int, byte[], int, int) ）
    
    该比较是一致equals ，更具体地以下适用于阵列a和b与指定的范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别地）：
    
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Byte.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 第一个要比较的数组
    
    aFromIndex - 要比较的第一个数组中第一个元素的索引（含）
    
    aToIndex - 要比较的第一个数组中最后一个元素的索引（独占）
    
    b - 要比较的第二个数组
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    值0如果超过指定范围的第一和第二个数组是相等的并且包含相同的元素相同的顺序; 小于0的值，如果在指定范围内，第一个数组的字典数字小于第二个数组; 大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一个阵列是 null
    
    从以下版本开始：
    
    9
  - compareUnsigned
```
public static int compareUnsigned(byte[] a,
                                  byte[] b)
```
    比较两个byte阵列在byte ，数字处理元素为无符号。
    如果两个阵列共享一个共同的前缀，那么词典比较是比较两个元素的结果，就像在Byte.compareUnsigned(byte, byte) ，在作为前缀长度的各个数组内的索引。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(byte[], byte[]) ）
    
    A null阵列引用在字典上小于非null阵列引用。两个null数组引用被认为是相等的。
    API Note:
    
    该方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Byte.compareUnsigned(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 第一个要比较的数组
    
    b - 要比较的第二个数组
    
    结果
    
    值0如果第一和第二个数组是相等的并且包含相同的元素相同的顺序; 小于0的值，如果第一个数组的字典数字小于第二个数组; 如果第一个数组的字典大小超过第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compareUnsigned
```
public static int compareUnsigned(byte[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  byte[] b,
                                  int bFromIndex,
                                  int bToIndex)
```
    将两个byte阵列按照byte顺序比较在指定范围内，将元素数字处理为无符号。
    如果两个数组在指定范围内共享一个共同的前缀，那么词典比较就是比较两个元素的结果，如Byte.compareUnsigned(byte, byte)那样，在相应的数组中作为前缀长度的相对索引。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(byte[], int, int, byte[], int, int) ）
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Byte.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 第一个要比较的数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中的最后一个元素的索引（独占）
    
    b - 第二个数组进行比较
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    值0如果超过指定范围的第一和第二个数组是相等的并且以相同的顺序包含相同的元素; 小于0的值，如果超过指定范围，则第一个数组的字典数字小于第二个数组; 并且大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或者是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组为空
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(short[] a,
                          short[] b)
```
    short字典顺序比较两个short阵列。
    如果两个阵列共享一个共同的前缀，那么词典比较是比较两个元素的结果，就像在Short.compare(short, short)一样，作为前缀长度的各个数组内的索引。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(short[], short[])。）
    
    A null阵列引用在字典上小于非null阵列引用。两个null数组引用被认为是相等的。
    
    比较与equals一致，更具体地说，对于阵列a和b ，具体如下：
    
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    API Note:
    
    此方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Short.compare(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 要比较的第一个数组
    
    b - 第二个数组进行比较
    
    结果
    
    值0如果第一和第二个数组是相等的并且包含相同的元素的顺序; 如果第一个数组的字典数字小于第二个数组，则该值小于0 ; 如果第一个数组的字典大小超过第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(short[] a,
                          int aFromIndex,
                          int aToIndex,
                          short[] b,
                          int bFromIndex,
                          int bToIndex)
```
    比较两个short阵列在short指定的范围。
    如果两个数组在指定的范围内共享一个共同的前缀，那么词典比较就是比较两个元素的结果，如Short.compare(short, short)那样，在作为前缀长度的相应数组中的相对索引处。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(short[], int, int, short[], int, int) ）
    
    该比较是一致equals ，更具体地以下适用于阵列a和b与指定的范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别地）：
    
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Short.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 第一个要比较的数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中的最后一个元素的索引（独占）
    
    b - 第二个数组进行比较
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    值0如果在指定的范围内，第一和第二个数组是相等的，并且以相同的顺序包含相同的元素; 如果超过指定范围，第一个数组的字典数字小于第二个数组，则该值小于0 ; 大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组是 null
    
    从以下版本开始：
    
    9
  - compareUnsigned
```
public static int compareUnsigned(short[] a,
                                  short[] b)
```
    比较两个short阵列的字典，数字处理元素为无符号。
    如果两个阵列共享一个共同的前缀，那么词典比较是比较两个元素的结果，就像在Short.compareUnsigned(short, short)一样，作为前缀长度的各个数组内的索引。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（见mismatch(short[], short[])关于常用和正确的前缀的定义。）
    
    A null阵列引用在字典上小于非null阵列引用。两个null数组引用被认为是相等的。
    API Note:
    
    该方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Short.compareUnsigned(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 第一个要比较的数组
    
    b - 要比较的第二个数组
    
    结果
    
    值0如果第一和第二个数组相等并且以相同的顺序包含相同的元素; 如果第一个数组的字典数字小于第二个数组，则该值小于0 ; 如果第一个数组的字典大于第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compareUnsigned
```
public static int compareUnsigned(short[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  short[] b,
                                  int bFromIndex,
                                  int bToIndex)
```
    将两个short阵列按照short顺序比较在指定范围内，将元素数字处理为无符号。
    如果两个数组在指定的范围内共享一个公用的前缀，那么词典比较就是比较两个元素的结果，就像在Short.compareUnsigned(short, short)中一样，在相应的数组内的相对索引是前缀的长度。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(short[], int, int, short[], int, int) ）
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Short.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 要比较的第一个数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中最后一个元素的索引（独占）
    
    b - 第二个数组进行比较
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    值0如果超过指定的范围，第一和第二个数组是相等的，并且包含相同的顺序的元素; 小于0的值，如果超过指定范围，则第一个数组的字典数字小于第二个数组; 大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组为空
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(char[] a,
                          char[] b)
```
    char字典顺序比较两个char阵列。
    如果两个数组共享一个共同的前缀，那么词典比较是比较两个元素的结果，如Character.compare(char, char)所示，在作为前缀长度的各个数组内的索引处。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(char[], char[]) ）
    
    A null阵列引用在字典上小于非null阵列引用。两个null数组引用被认为是相等的。
    
    比较与equals一致，更具体地说，对于阵列a和b ：
    
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    API Note:
    
    此方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Character.compare(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 要比较的第一个数组
    
    b - 第二个数组进行比较
    
    结果
    
    值0如果第一和第二个数组是相等的并且包含相同的元素在相同的顺序; 如果第一个数组的字典数字小于第二个数组，则该值小于0 ; 如果第一个数组的字典数字大于第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(char[] a,
                          int aFromIndex,
                          int aToIndex,
                          char[] b,
                          int bFromIndex,
                          int bToIndex)
```
    比较两个char阵列在char指定的范围。
    如果两个数组在指定的范围内共享一个共同的前缀，那么词典比较就是比较两个元素的结果，就像在Character.compare(char, char)中一样，在作为前缀长度的相应数组中的相对索引处。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(char[], int, int, char[], int, int) ）
    
    该比较是一致equals ，更具体地以下适用于阵列a和b与指定的范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别地）：
    
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Character.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 要比较的第一个数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中的最后一个元素的索引（独占）
    
    b - 第二个数组进行比较
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中的最后一个元素的索引（独占）
    
    结果
    
    值0如果超过指定范围的第一和第二个数组是相等的，并且以相同的顺序包含相同的元素; 小于0的值，如果超过指定范围，则第一个数组的字典数字小于第二个数组; 大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组是 null
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(int[] a,
                          int[] b)
```
    int字典顺序比较两个int阵列。
    如果两个数组共享一个共同的前缀，则字典比较是比较两个元素的结果，如Integer.compare(int, int)所示，在作为前缀长度的各个数组内的索引处。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(int[], int[]) ）
    
    A null阵列引用在字典上被认为小于非null阵列引用。两个null数组引用被认为是相等的。
    
    该比较与equals是一致的，更具体地说，对于阵列a和b ，更具体地说：
    
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    API Note:
    
    此方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Integer.compare(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 第一个要比较的数组
    
    b - 第二个数组进行比较
    
    结果
    
    值0如果第一个和第二个数组是相等的并且包含相同的顺序的元素; 小于0的值，如果第一个数组的字典数字小于第二个数组; 如果第一个数组的字典大于第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(int[] a,
                          int aFromIndex,
                          int aToIndex,
                          int[] b,
                          int bFromIndex,
                          int bToIndex)
```
    比较两个int阵列在字典上超过指定的范围。
    如果两个数组在指定的范围内共享一个公用的前缀，那么字典比较就是比较两个元素的结果，如Integer.compare(int, int)那样，在作为前缀长度的相应数组中的相对索引处。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(int[], int, int, int[], int, int) ）
    
    该比较是一致equals ，更具体地以下适用于阵列a和b与指定的范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别地）：
    
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Integer.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 要比较的第一个数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中最后一个元素的索引（独占）
    
    b - 要比较的第二个数组
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    值0如果在指定的范围内，第一和第二个数组是相等的，并且以相同的顺序包含相同的元素; 小于0的值，如果在指定范围内，第一个数组在字典上小于第二个数组; 并且大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组是 null
    
    从以下版本开始：
    
    9
  - compareUnsigned
```
public static int compareUnsigned(int[] a,
                                  int[] b)
```
    比较两个int阵列的字典，数字处理元素为无符号。
    如果两个阵列共享一个共同的前缀，那么词典比较是比较两个元素的结果，就像在Integer.compareUnsigned(int, int)一样，作为前缀长度的相应数组中的索引。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(int[], int[]) ）
    
    A null阵列引用在字典上小于非null阵列引用。两个null数组引用被认为是相等的。
    API Note:
    
    该方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Integer.compareUnsigned(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 第一个要比较的数组
    
    b - 第二个数组进行比较
    
    结果
    
    值0如果第一和第二个数组是相等的并且包含相同的元素在相同的顺序; 如果第一个数组的字典数字小于第二个数组，则该值小于0 ; 如果第一个数组的字典大于第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compareUnsigned
```
public static int compareUnsigned(int[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  int[] b,
                                  int bFromIndex,
                                  int bToIndex)
```
    将两个int数组按照指定的范围进行int比较，将元素数字化处理为无符号。
    如果两个数组在指定的范围内共享一个共同的前缀，那么词典比较是比较两个元素的结果，就像在Integer.compareUnsigned(int, int)中一样，在作为前缀长度的相应数组内的相对索引处。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(int[], int, int, int[], int, int) ）
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Integer.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 第一个要比较的数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中的最后一个元素的索引（独占）
    
    b - 第二个数组进行比较
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    值0如果超过指定的范围，第一和第二个数组是相等的，并且包含相同的顺序的元素; 小于0的值，如果超过指定范围，则第一个数组按字典顺序小于第二个数组; 并且大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或者如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组为空
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(long[] a,
                          long[] b)
```
    long字典顺序比较两个long阵列。
    如果两个数组共享一个共同的前缀，那么词典比较就是比较两个元素的结果，就像在Long.compare(long, long)一样，在作为前缀长度的各个数组内的一个索引。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（有关常用和正确的前缀的定义，请参阅mismatch(long[], long[]) ）
    
    null阵列引用在字典上小于非null阵列引用。两个null数组引用被认为是相等的。
    
    比较与equals一致，更具体地说，对于阵列a和b ，更具体地说：
    
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    API Note:
    
    该方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Long.compare(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 要比较的第一个数组
    
    b - 第二个数组进行比较
    
    结果
    
    值0如果第一和第二个数组是相等的并且包含相同的元素的顺序; 小于0的值，如果第一个数组的字典数字小于第二个数组; 如果第一个数组的字典大于第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(long[] a,
                          int aFromIndex,
                          int aToIndex,
                          long[] b,
                          int bFromIndex,
                          int bToIndex)
```
    比较两个long阵列在long指定的范围。
    如果两个数组在指定的范围内共享一个公用的前缀，那么词典比较就是比较两个元素的结果，就像在Long.compare(long, long)中一样，在相应的数组中作为前缀长度的相对索引。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（见mismatch(long[], int, int, long[], int, int)关于常用和正确的前缀的定义。）
    
    该比较是一致equals ，更具体地以下适用于阵列a和b与指定的范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别地）：
    
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Long.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 要比较的第一个数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中的最后一个元素的索引（独占）
    
    b - 第二个数组进行比较
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中的最后一个元素的索引（独占）
    
    结果
    
    值0如果超过指定范围的第一和第二个数组是相等的并且以相同的顺序包含相同的元素; 小于0的值，如果超过指定范围，则第一个数组的字典数字小于第二个数组; 大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一个阵列是 null
    
    从以下版本开始：
    
    9
  - compareUnsigned
```
public static int compareUnsigned(long[] a,
                                  long[] b)
```
    比较两个long阵列的字典，数字处理元素为无符号。
    如果两个数组共享一个共同的前缀，那么词典比较是比较两个元素的结果，就像在Long.compareUnsigned(long, long)一样，作为前缀长度的相应数组中的索引。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（见mismatch(long[], long[])，用于定义一个通用和正确的前缀。）
    
    A null阵列引用在字典上小于非null阵列引用。两个null数组引用被认为是相等的。
    API Note:
    
    此方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Long.compareUnsigned(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 第一个要比较的数组
    
    b - 要比较的第二个数组
    
    结果
    
    值0如果第一和第二个数组是相等的并且包含相同的元素的顺序; 小于0的值，如果第一个数组按字典顺序小于第二个数组; 如果第一个数组的字典大于第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compareUnsigned
```
public static int compareUnsigned(long[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  long[] b,
                                  int bFromIndex,
                                  int bToIndex)
```
    将两个long数组按照long顺序比较在指定范围内，将元素数字化处理为无符号。
    如果两个数组在指定的范围内共享一个共同的前缀，则词典比较是比较两个元素的结果，如Long.compareUnsigned(long, long)所示，在相应的数组中作为前缀长度的相对索引。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关常用和正确的前缀的定义，请参阅mismatch(long[], int, int, long[], int, int) ）
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Long.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 要比较的第一个数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中最后一个元素的索引（独占）
    
    b - 要比较的第二个数组
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中的最后一个元素的索引（独占）
    
    结果
    
    值0如果超过指定的范围，第一和第二个数组是相等的并且以相同的顺序包含相同的元素; 小于0的值，如果在指定范围内，第一个数组的字典数字小于第二个数组; 大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或者如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组为空
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(float[] a,
                          float[] b)
```
    float字典顺序比较两个float阵列。
    如果两个数组共享一个共同的前缀，则词典比较是比较两个元素的结果，就像在Float.compare(float, float)中一样，作为前缀长度的各个数组内的索引。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（有关常用和正确的前缀的定义，请参阅mismatch(float[], float[]) ）。
    
    null阵列引用在字典上被认为小于非null阵列引用。两个null数组引用被认为是相等的。
    
    比较与equals一致，更具体地说，对于阵列a和b
    
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    API Note:
    
    该方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Float.compare(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 第一个要比较的数组
    
    b - 第二个数组进行比较
    
    结果
    
    值0如果第一和第二个数组是相同的，并且以相同的顺序包含相同的元素; 小于0的值，如果第一个数组的字典小于第二个数组; 如果第一个数组的字典大小大于第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(float[] a,
                          int aFromIndex,
                          int aToIndex,
                          float[] b,
                          int bFromIndex,
                          int bToIndex)
```
    比较两个float阵列在字典上超过指定的范围。
    如果两个数组在指定的范围内共享一个公用的前缀，那么词典比较就是比较两个元素的结果，就像在Float.compare(float, float)一样，在相应的数组内的相对索引是前缀的长度。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关常用和正确的前缀的定义，请参阅mismatch(float[], int, int, float[], int, int) ）
    
    该比较是一致equals ，更具体地以下适用于阵列a和b与指定的范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别地）：
    
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Float.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 第一个要比较的数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中最后一个元素的索引（独占）
    
    b - 第二个数组进行比较
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中的最后一个元素的索引（独占）
    
    结果
    
    值0如果超过指定范围的第一和第二个数组是相同的，并且以相同的顺序包含相同的元素; 小于0的值，如果在指定范围内，第一个数组的字典数字小于第二个数组; 大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组是 null
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(double[] a,
                          double[] b)
```
    double字典顺序比较两个double阵列。
    如果两个数组共享一个共同的前缀，那么词典比较就是比较两个元素的结果，如Double.compare(double, double)那样，在作为前缀长度的各个数组中的索引处。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(double[], double[]) ）
    
    A null阵列引用在字典上被认为小于非null数组引用。两个null数组引用被认为是相等的。
    
    比较与equals一致，更具体地说，对于阵列a和b ，具体如下：
    
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    API Note:
    
    此方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Double.compare(a[i], b[i]); return a.length - b.length;
    
    参数
    
    a - 第一个数组进行比较
    
    b - 第二个数组进行比较
    
    结果
    
    值0如果第一和第二个数组是相等的并且以相同的顺序包含相同的元素; 如果第一个数组的字典数字小于第二个数组，则该值小于0 ; 如果第一个数组的字典大于第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(double[] a,
                          int aFromIndex,
                          int aToIndex,
                          double[] b,
                          int bFromIndex,
                          int bToIndex)
```
    比较两个double阵列在字典上超过指定的范围。
    如果两个数组在指定的范围内共享一个共同的前缀，那么词典比较就是比较两个元素的结果，如Double.compare(double, double)那样，在作为前缀长度的相应数组内的相对索引处。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(double[], int, int, double[], int, int) ）
    
    该比较是一致equals ，更具体地以下适用于阵列a和b与指定的范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别地）：
    
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    API Note:
    
    此方法的行为如下：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Double.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数
    
    a - 第一个要比较的数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中最后一个元素的索引（独占）
    
    b - 第二个数组进行比较
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    值0如果在指定的范围内，第一和第二个数组是相等的，并且包含相同的顺序相同的元素; 小于0的值，如果超过指定范围，第一个数组的字典数字小于第二个数组; 大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一个阵列是 null
    
    从以下版本开始：
    
    9
  - compare
```
public static <T extends Comparable<? super T>> int compare(T[] a,
                                                            T[] b)
```
    比较两个Object阵列，在可比较的元素内，按字典顺序。
    如果两个数组共享一个共同的前缀，则字典比较是将T类型的两个元素作为前缀长度的相应数组中的索引i进行比较的结果，如下所示：
    
    Comparator.nullsFirst(Comparator.<T>naturalOrder()). compare(a[i], b[i])
    否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（有关公用和正确前缀的定义，请参阅mismatch(Object[], Object[])。）
    A null阵列引用在字典上小于非null数组引用。两个null数组引用被认为是相等的。 A null数组元素比非null数组元素进行字典比对。两个null数组元素被认为是相等的。
    
    比较与equals一致，更具体地说，对于阵列a和b ，具体如下：
    
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    API Note:
    
    该方法的行为就像（对于非null数组引用和元素）：
    
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return a[i].compareTo(b[i]); return a.length - b.length;
    
    参数类型
    
    T - 类似的数组元素
    
    参数
    
    a - 第一个要比较的数组
    
    b - 第二个数组进行比较
    
    结果
    
    值0如果第一和第二个数组是相等的并且以相同的顺序包含相同的元素; 小于0的值，如果第一个数组按字典顺序小于第二个数组; 如果第一个数组的字典大于第二个数组，则值大于0
    
    从以下版本开始：
    
    9
  - compare
```
public static <T extends Comparable<? super T>> int compare(T[] a,
                                                            int aFromIndex,
                                                            int aToIndex,
                                                            T[] b,
                                                            int bFromIndex,
                                                            int bToIndex)
```
    比较两个Object阵列在字典上超过指定的范围。
    如果两个数组在指定范围内共享公用前缀，则字典比较是将T类型的两个元素作为前缀长度的相应数组中的相对索引i进行比较的结果，如下所示：
    
    Comparator.nullsFirst(Comparator.<T>naturalOrder()). compare(a[aFromIndex + i, b[bFromIndex + i])
    否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（见mismatch(Object[], int, int, Object[], int, int)，用于定义一个普通和正确的前缀。）
    该比较是一致equals ，更具体地以下适用于阵列a和b与指定的范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别地）：
    
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    API Note:
    
    该方法的行为就像（对于非null数组元素）：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return a[aFromIndex + i].compareTo(b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数类型
    
    T - 类似的数组元素
    
    参数
    
    a - 第一个要比较的数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中的最后一个元素的索引（独占）
    
    b - 要比较的第二个数组
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    值0如果超过指定范围的第一和第二个数组是相同的并且以相同的顺序包含相同的元素; 小于0的值，如果超过指定范围，则第一个数组的字典数字小于第二个数组; 大于0的值，如果超过指定的范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或者是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任何一个数组是 null
    
    从以下版本开始：
    
    9
  - compare
```
public static <T> int compare(T[] a,
                              T[] b,
                              Comparator<? super T> cmp)
```
    比较两个Object阵列，使用指定的比较器进行字典比对。
    如果两个数组共享一个共同的前缀，则字典比较是与指定的比较器比较的两个元素的结果，两个元素在作为前缀长度的各个数组中的索引处。否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。（见mismatch(Object[], Object[])定义一个通用和正确的前缀。）
    
    A null阵列引用在字典上小于非null阵列引用。两个null数组引用被认为是相等的。
    API Note:
    
    此方法的行为就像（对于非null数组引用）：
    
    int i = Arrays.mismatch(a, b, cmp); if (i >= 0 && i < Math.min(a.length, b.length)) return cmp.compare(a[i], b[i]); return a.length - b.length;
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    a - 第一个要比较的数组
    
    b - 第二个数组进行比较
    
    cmp - 比较器来比较数组元素
    
    结果
    
    值0如果第一个和第二个数组相等并且包含相同的元素在相同的顺序; 小于0的值，如果第一个数组按字典顺序小于第二个数组; 如果第一个数组的字典大小大于第二个数组，则值大于0
    
    异常
    
    NullPointerException - 如果比较器是 null
    
    从以下版本开始：
    
    9
  - compare
```
public static <T> int compare(T[] a,
                              int aFromIndex,
                              int aToIndex,
                              T[] b,
                              int bFromIndex,
                              int bToIndex,
                              Comparator<? super T> cmp)
```
    比较两个Object阵列在指定范围内的字典。
    如果两个数组在指定的范围内共享一个共同的前缀，则字典比较是与指定比较器的比较结果，两个元素在作为前缀长度的相应数组内的相对索引处。否则，一个数组是另一个数组的正确的前缀，字典比较是比较两个范围长度的结果。（有关公用和正确的前缀的定义，请参阅mismatch(Object[], int, int, Object[], int, int) ）
    API Note:
    
    该方法的行为就像（对于非null数组元素）：
    
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex, cmp); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return cmp.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    a - 第一个要比较的数组
    
    aFromIndex - 要比较的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要比较的第一个数组中的最后一个元素的索引（独占）
    
    b - 第二个数组进行比较
    
    bFromIndex - 要比较的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要比较的第二个数组中最后一个元素的索引（独占）
    
    cmp - 比较数组元素的比较器
    
    结果
    
    值0如果超过指定范围的第一和第二个数组是相等的，并且以相同的顺序包含相同的元素; 小于0的值，如果超过指定范围，第一个数组的字典数字小于第二个数组; 大于0的值，如果超过指定范围，则第一个数组的字典大于第二个数组
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或者如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任何一个阵列或比较器是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(boolean[] a,
                           boolean[] b)
```
    查找并返回两个boolean数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。索引将在0（包括）到最小数组的长度（包括）的范围内。
    如果两个数组共享一个共同的前缀，则返回的索引是公共前缀的长度，因此在相应数组内的该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的正确前缀，则返回的索引是较小数组的长度，因此该索引仅适用于较大的数组。否则，没有不匹配。
    
    如果以下表达式为真， a两个非null数组（ a和b ）共享长度为pl的公共前缀：
    
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    如果下列表达式为真， a两个非null阵列（ a和b ）共享正确的前缀：
    
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    参数
    
    a - 要测试不匹配的第一个数组
    
    b - 要测试不匹配的第二个数组
    
    结果
    
    两个阵列之间的首次不匹配的索引，否则为 -1 。
    
    异常
    
    NullPointerException - 如果任一个阵列是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(boolean[] a,
                           int aFromIndex,
                           int aToIndex,
                           boolean[] b,
                           int bFromIndex,
                           int bToIndex)
```
    查找并返回指定范围内两个boolean数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。索引将在0（含）以上的范围内，直到较小范围的长度（包括）。
    如果两个数组在指定的范围内共享一个共同的前缀，那么返回的相对索引是公共前缀的长度，因此在相应数组内的相对索引处的两个元素之间存在不匹配。如果一个数组是另一个的正确前缀，超过指定范围，则返回的相对索引是较小范围的长度，因此相对索引仅对范围较大的数组有效。否则，没有不匹配。
    
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别），分享长度的公共前缀pl如果满足下列表达式为真：
    
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex ）分别共享一个适当如果满足下列表达式为真：
    
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    参数
    
    a - 要测试不匹配的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要测试不匹配的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    两个阵列之间在指定范围内的首次不匹配的相对索引，否则为 -1 。
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(byte[] a,
                           byte[] b)
```
    查找并返回两个byte数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。索引将在0（包括）到最小数组的长度（包括）的范围内。
    如果两个数组共享一个共同的前缀，则返回的索引是公共前缀的长度，因此在相应数组内的该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的正确前缀，则返回的索引是较小数组的长度，因此该索引仅适用于较大的数组。否则，没有不匹配。
    
    如果以下表达式为真， a两个非null阵列（ a和b ）共享长度为pl的公共前缀：
    
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    如果下列表达式为真， a两个非null阵列（ a和b ）共享正确的前缀：
    
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    参数
    
    a - 要测试不匹配的第一个数组
    
    b - 要测试不匹配的第二个数组
    
    结果
    
    两个阵列之间的首次匹配的索引，否则为 -1 。
    
    异常
    
    NullPointerException - 如果任何一个数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(byte[] a,
                           int aFromIndex,
                           int aToIndex,
                           byte[] b,
                           int bFromIndex,
                           int bToIndex)
```
    查找并返回指定范围内两个byte数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。索引将在0（含）以上的范围内，直到较小范围的长度（包括）。
    如果两个数组在指定的范围内共享一个共同的前缀，那么返回的相对索引是公共前缀的长度，因此在相应数组内的相对索引处的两个元素之间存在不匹配。如果一个数组是另一个的正确前缀，超过指定范围，则返回的相对索引是较小范围的长度，因此相对索引仅对范围较大的数组有效。否则，没有不匹配。
    
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别），分享长度的公共前缀pl如果满足下列表达式为真：
    
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex ）分别共享一个适当如果满足下列表达式为真：
    
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    参数
    
    a - 要测试不匹配的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要测试不匹配的第二个数组
    
    bFromIndex - 要测试的第二个数组中第一个元素的索引（含）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    两个阵列之间在指定范围内的首次不匹配的相对索引，否则为 -1 。
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一阵列是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(char[] a,
                           char[] b)
```
    查找并返回两个char数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。索引将在0（包括）到最小数组的长度（包括）的范围内。
    如果两个数组共享一个共同的前缀，则返回的索引是公共前缀的长度，因此在相应数组内的该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的正确前缀，则返回的索引是较小数组的长度，因此该索引仅适用于较大的数组。否则，没有不匹配。
    
    如果以下表达式为真， a两个非null数组（ a和b ）共享长度为pl的公共前缀：
    
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    如果以下表达式为真， a两个非null数组（ a和b ）共享正确的前缀：
    
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    参数
    
    a - 要测试不匹配的第一个数组
    
    b - 要测试不匹配的第二个数组
    
    结果
    
    两个阵列之间的首次匹配的索引，否则为 -1 。
    
    异常
    
    NullPointerException - 如果任何一个数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(char[] a,
                           int aFromIndex,
                           int aToIndex,
                           char[] b,
                           int bFromIndex,
                           int bToIndex)
```
    查找并返回指定范围内两个char数组之间的第一个不匹配的相对索引，否则返回-1，如果未发现不匹配。索引将在0（含）以上的范围内，直到较小范围的长度（包括）。
    如果两个数组在指定的范围内共享一个共同的前缀，那么返回的相对索引是公共前缀的长度，因此在相应数组内的相对索引处的两个元素之间存在不匹配。如果一个数组是另一个的正确前缀，超过指定范围，则返回的相对索引是较小范围的长度，因此相对索引仅对范围较大的数组有效。否则，没有不匹配。
    
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别），分享长度的公共前缀pl如果满足下列表达式为真：
    
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex ）分别共享一个适当如果满足下列表达式为真：
    
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    参数
    
    a - 要测试不匹配的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要测试不匹配的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    两个阵列之间在指定范围内的首次不匹配的相对索引，否则为 -1 。
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(short[] a,
                           short[] b)
```
    查找并返回两个short数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。索引将在0（包括）到最小数组的长度（包括）的范围内。
    如果两个数组共享一个共同的前缀，则返回的索引是公共前缀的长度，因此在相应数组内的该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的正确前缀，则返回的索引是较小数组的长度，因此该索引仅适用于较大的数组。否则，没有不匹配。
    
    如果以下表达式为真， a两个非null阵列（ a和b ）共享长度为pl的公共前缀：
    
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    如果以下表达式为真， a两个非null阵列（ a和b ）共享正确的前缀：
    
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    参数
    
    a - 要测试不匹配的第一个数组
    
    b - 要测试不匹配的第二个数组
    
    结果
    
    两个阵列之间的第一个不匹配的索引，否则为 -1 。
    
    异常
    
    NullPointerException - 如果任一数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(short[] a,
                           int aFromIndex,
                           int aToIndex,
                           short[] b,
                           int bFromIndex,
                           int bToIndex)
```
    查找并返回指定范围内的两个short数组之间的第一个不匹配的相对索引，否则返回-1，如果没有发现不匹配。索引将在0（含）以上的范围内，直到较小范围的长度（包括）。
    如果两个数组在指定的范围内共享一个共同的前缀，那么返回的相对索引是公共前缀的长度，因此在相应数组内的相对索引处的两个元素之间存在不匹配。如果一个数组是另一个的正确前缀，超过指定范围，则返回的相对索引是较小范围的长度，因此相对索引仅对范围较大的数组有效。否则，没有不匹配。
    
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别），分享长度的公共前缀pl如果满足下列表达式为真：
    
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex ）分别共享一个适当如果满足下列表达式为真：
    
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    参数
    
    a - 要测试不匹配的第一个数组
    
    aFromIndex - 要测试的第一个数组中第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中的最后一个元素的索引（独占）
    
    b - 要测试不匹配的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    两个阵列之间在指定范围内的首次不匹配的相对索引，否则为 -1 。
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一个阵列是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(int[] a,
                           int[] b)
```
    查找并返回两个int数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。索引将在0（包括）到最小数组的长度（包括）的范围内。
    如果两个数组共享一个共同的前缀，则返回的索引是公共前缀的长度，因此在相应数组内的该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的正确前缀，则返回的索引是较小数组的长度，因此该索引仅适用于较大的数组。否则，没有不匹配。
    
    如果以下表达式为真， a两个非null阵列a和b共享长度为pl的公共前缀：
    
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    如果下列表达式为真， a两个非null数组（ a和b ）共享正确的前缀：
    
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    参数
    
    a - 要测试不匹配的第一个数组
    
    b - 要测试不匹配的第二个数组
    
    结果
    
    两个阵列之间的首次匹配的索引，否则为 -1 。
    
    异常
    
    NullPointerException - 如果任一个数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(int[] a,
                           int aFromIndex,
                           int aToIndex,
                           int[] b,
                           int bFromIndex,
                           int bToIndex)
```
    查找并返回指定范围内两个int数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。索引将在0（含）以上的范围内，直到较小范围的长度（包括）。
    如果两个数组在指定的范围内共享一个共同的前缀，那么返回的相对索引是公共前缀的长度，因此在相应数组内的相对索引处的两个元素之间存在不匹配。如果一个数组是另一个的正确前缀，超过指定范围，则返回的相对索引是较小范围的长度，因此相对索引仅对范围较大的数组有效。否则，没有不匹配。
    
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别），分享长度的公共前缀pl如果满足下列表达式为真：
    
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex ）分别共享一个适当如果满足下列表达式为真：
    
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    参数
    
    a - 要测试不匹配的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要测试不匹配的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    两个阵列之间在指定范围内的首次不匹配的相对索引，否则为 -1 。
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或者如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任何一个数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(long[] a,
                           long[] b)
```
    查找并返回两个long数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。索引将在0（包括）到最小数组的长度（包括）的范围内。
    如果两个数组共享一个共同的前缀，则返回的索引是公共前缀的长度，因此在相应数组内的该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的正确前缀，则返回的索引是较小数组的长度，因此该索引仅适用于较大的数组。否则，没有不匹配。
    
    如果以下表达式为真， a两个非null阵列（ a和b ）共享长度为pl的公共前缀：
    
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    如果以下表达式为真， a两个非null阵列（ a和b ）共享正确的前缀：
    
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    参数
    
    a - 要测试不匹配的第一个数组
    
    b - 要测试不匹配的第二个数组
    
    结果
    
    两个阵列之间的首次匹配的索引，否则为 -1 。
    
    异常
    
    NullPointerException - 如果任一个数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(long[] a,
                           int aFromIndex,
                           int aToIndex,
                           long[] b,
                           int bFromIndex,
                           int bToIndex)
```
    查找并返回指定范围内的两个long数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。索引将在0（含）以上的范围内，直到较小范围的长度（包括）。
    如果两个数组在指定的范围内共享一个共同的前缀，那么返回的相对索引是公共前缀的长度，因此在相应数组内的相对索引处的两个元素之间存在不匹配。如果一个数组是另一个的正确前缀，超过指定范围，则返回的相对索引是较小范围的长度，因此相对索引仅对范围较大的数组有效。否则，没有不匹配。
    
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别），分享长度的公共前缀pl如果满足下列表达式为真：
    
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex ）分别共享一个适当如果满足下列表达式为真：
    
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    参数
    
    a - 要测试不匹配的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要测试不匹配的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    两个阵列之间在指定范围内的首次不匹配的相对索引，否则为 -1 。
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(float[] a,
                           float[] b)
```
    查找并返回两个float数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。索引将在0（包括）到最小数组的长度（包括）的范围内。
    如果两个数组共享一个共同的前缀，则返回的索引是公共前缀的长度，因此在相应数组内的该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的正确前缀，则返回的索引是较小数组的长度，因此该索引仅适用于较大的数组。否则，没有不匹配。
    
    如果下列表达式为真， a两个非null数组a和b共享长度为pl的公共前缀：
    
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && Float.compare(a[pl], b[pl]) != 0
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    如果下列表达式为真， a两个非null数组（ a和b ）共享正确的前缀：
    
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    参数
    
    a - 要测试不匹配的第一个数组
    
    b - 要测试不匹配的第二个数组
    
    结果
    
    两个数组之间的第一个不匹配的索引，否则为 -1 。
    
    异常
    
    NullPointerException - 如果任何一个数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(float[] a,
                           int aFromIndex,
                           int aToIndex,
                           float[] b,
                           int bFromIndex,
                           int bToIndex)
```
    查找并返回指定范围内两个float数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。索引将在0（含）以上的范围内，直到较小范围的长度（包括）。
    如果两个数组在指定的范围内共享一个共同的前缀，那么返回的相对索引是公共前缀的长度，因此在相应数组内的相对索引处的两个元素之间存在不匹配。如果一个数组是另一个的正确前缀，超过指定范围，则返回的相对索引是较小范围的长度，因此相对索引仅对范围较大的数组有效。否则，没有不匹配。
    
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别），分享长度的公共前缀pl如果满足下列表达式为真：
    
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && Float.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex ）分别共享一个适当如果满足下列表达式为真：
    
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    参数
    
    a - 要测试不匹配的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中的最后一个元素的索引（独占）
    
    b - 要测试不匹配的第二个数组
    
    bFromIndex - 要测试的第二个数组中第一个元素的索引（含）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    两个阵列之间在指定范围内的首次不匹配的相对索引，否则为 -1 。
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或者如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任何一个数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(double[] a,
                           double[] b)
```
    查找并返回两个double数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。索引将在0（包括）到最小数组的长度（包括）的范围内。
    如果两个数组共享一个共同的前缀，则返回的索引是公共前缀的长度，因此在相应数组内的该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的正确前缀，则返回的索引是较小数组的长度，因此该索引仅适用于较大的数组。否则，没有不匹配。
    
    如果以下表达式为真， a两个非null阵列（ a和b ）共享长度为pl的公共前缀：
    
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && Double.compare(a[pl], b[pl]) != 0
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    如果下列表达式为真， a两个非null数组（ a和b ）共享正确的前缀：
    
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    参数
    
    a - 要测试不匹配的第一个数组
    
    b - 要测试不匹配的第二个数组
    
    结果
    
    两个阵列之间的首次匹配的索引，否则为 -1 。
    
    异常
    
    NullPointerException - 如果任一个数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(double[] a,
                           int aFromIndex,
                           int aToIndex,
                           double[] b,
                           int bFromIndex,
                           int bToIndex)
```
    查找并返回指定范围内两个double数组之间的第一个不匹配的相对索引，否则返回-1，如果未发现不匹配。索引将在0（含）以上的范围内，直到较小范围的长度（包括）。
    如果两个数组在指定的范围内共享一个共同的前缀，那么返回的相对索引是公共前缀的长度，因此在相应数组内的相对索引处的两个元素之间存在不匹配。如果一个数组是另一个的正确前缀，超过指定范围，则返回的相对索引是较小范围的长度，因此相对索引仅对范围较大的数组有效。否则，没有不匹配。
    
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别），分享长度的公共前缀pl如果满足下列表达式为真：
    
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && Double.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex ）分别共享一个适当如果满足下列表达式为真：
    
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    参数
    
    a - 要测试不匹配的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要测试不匹配的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    两个阵列之间在指定范围内的首次不匹配的相对索引，否则为 -1 。
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或者如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任一数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(Object[] a,
                           Object[] b)
```
    查找并返回两个Object数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。索引将在0（包括）到最小数组的长度（包括）的范围内。
    如果两个数组共享一个共同的前缀，则返回的索引是公共前缀的长度，因此在相应数组内的该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的正确前缀，则返回的索引是较小数组的长度，因此该索引仅适用于较大的数组。否则，没有不匹配。
    
    如果下列表达式为真， a两个非null阵列a和b共享长度为pl的公共前缀：
    
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && !Objects.equals(a[pl], b[pl])
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    如果以下表达式为真， a两个非null阵列（ a和b ）共享正确的前缀：
    
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    参数
    
    a
    
    b - 要测试不匹配的第二个数组
    
    结果
    
    这两个数组之间的第一个不匹配的索引，否则为 -1 。
    
    异常
    
    NullPointerException - 如果任一个阵列是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static int mismatch(Object[] a,
                           int aFromIndex,
                           int aToIndex,
                           Object[] b,
                           int bFromIndex,
                           int bToIndex)
```
    查找并返回指定范围内两个Object数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。索引将在0（含）以上的范围内，直到较小范围的长度（包括）。
    如果两个数组在指定的范围内共享一个共同的前缀，那么返回的相对索引是公共前缀的长度，因此在相应数组内的相对索引处的两个元素之间存在不匹配。如果一个数组是另一个的正确前缀，超过指定范围，则返回的相对索引是较小范围的长度，因此相对索引仅对范围较大的数组有效。否则，没有不匹配。
    
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别），分享长度的公共前缀pl如果满足下列表达式为真：
    
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && !Objects.equals(a[aFromIndex + pl], b[bFromIndex + pl])
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex ）分别共享一个适当如果满足下列表达式为真：
    
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    参数
    
    a - 要测试不匹配的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要测试不匹配的第二个数组
    
    bFromIndex - 要测试的第二个数组中的第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    结果
    
    两个阵列之间在指定范围内的首次不匹配的相对索引，否则为 -1 。
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或者如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任何一个数组是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static <T> int mismatch(T[] a,
                               T[] b,
                               Comparator<? super T> cmp)
```
    查找并返回两个Object数组之间的第一个不匹配的索引，否则返回-1，如果没有发现不匹配。索引将在0（包括）到最小数组的长度（包括）的范围内。
    指定的比较器用于确定每个阵列中的两个数组元素是否不相等。
    
    如果两个数组共享一个共同的前缀，则返回的索引是公共前缀的长度，因此在相应数组内的该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的正确前缀，则返回的索引是较小数组的长度，因此该索引仅适用于较大的数组。否则，没有不匹配。
    
    如果以下表达式为真， a两个非null数组a和b共享长度为pl的公共前缀：
    
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl, cmp) cmp.compare(a[pl], b[pl]) != 0
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    如果以下表达式为真， a两个非null数组（ a和b ）共享正确的前缀：
    
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length), cmp)
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    a - 要测试不匹配的第一个数组
    
    b - 要测试不匹配的第二个数组
    
    cmp - 比较器来比较数组元素
    
    结果
    
    两个数组之间的第一个不匹配的索引，否则为 -1 。
    
    异常
    
    NullPointerException - 如果任何一个阵列或比较器是 null
    
    从以下版本开始：
    
    9
  - mismatch
```
public static <T> int mismatch(T[] a,
                               int aFromIndex,
                               int aToIndex,
                               T[] b,
                               int bFromIndex,
                               int bToIndex,
                               Comparator<? super T> cmp)
```
    查找并返回指定范围内两个Object数组之间的第一个不匹配的相对索引，否则返回-1（如果未发现不匹配）。索引将在0（含）以上的范围内，直到较小范围的长度（包括）。
    如果两个数组在指定的范围内共享一个共同的前缀，那么返回的相对索引是公共前缀的长度，因此在相应数组内的相对索引处的两个元素之间存在不匹配。如果一个数组是另一个的正确前缀，超过指定范围，则返回的相对索引是较小范围的长度，因此相对索引仅对范围较大的数组有效。否则，没有不匹配。
    
    两个非null阵列， a和b具有指定范围[ aFromIndex ， atoIndex ）和[ bFromIndex ， btoIndex分别），分享长度的公共前缀pl如果满足下列表达式为真：
    
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl, cmp) && cmp.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
    请注意，公共前缀长度为0表示每个阵列的第一个元素不匹配。
    null a b - aFromIndex atoIndex - bFromIndex btoIndex - bFromIndex btoIndex - bFromIndex btoIndex - bFromIndex btoIndex - bFromIndex btoIndex - bFromIndex btoIndex - bFromIndex btoIndex - bFromIndex btoIndex - bFromIndex btoIndex - bFromIndex btoIndex - bFromIndex btoIndex
    
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), cmp)
    参数类型
    
    T - 数组元素的类型
    
    参数
    
    a - 要测试不匹配的第一个数组
    
    aFromIndex - 要测试的第一个数组中的第一个元素的索引（包括）
    
    aToIndex - 要测试的第一个数组中最后一个元素的索引（独占）
    
    b - 要测试不匹配的第二个数组
    
    bFromIndex - 要测试的第二个数组中第一个元素的索引（包括）
    
    bToIndex - 要测试的第二个数组中最后一个元素的索引（独占）
    
    cmp - 比较数组元素比较器
    
    结果
    
    两个阵列之间在指定范围内的首次不匹配的相对索引，否则为 -1 。
    
    异常
    
    IllegalArgumentException - 如果是 aFromIndex > aToIndex或如果是 bFromIndex > bToIndex
    
    ArrayIndexOutOfBoundsException - 如果是 aFromIndex < 0 or aToIndex > a.length或如果是 bFromIndex < 0 or bToIndex > b.length
    
    NullPointerException - 如果任何一个阵列或比较器是 null
    
    从以下版本开始：
    
    9

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

equals

equals

equals

equals

equals