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

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

该班级是Java Collections Framework的成员。

从以下版本开始：

1.2

方法摘要

所有方法静态方法具体的方法
变量和类型	方法	描述
`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)`	使用二进制搜索算法在指定的long数组中搜索指定的值。
`static int`	`binarySearch(short[] a, int fromIndex, int toIndex, short key)`	使用二进制搜索算法搜索指定值的指定数组的范围。
`static int`	`binarySearch(short[] a, short key)`	使用二进制搜索算法在指定的short数组中搜索指定的值。
`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`阵列。
`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`阵列。
`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`阵列。
`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`阵列。
`static <T> int`	`compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)`	在指定范围内按字典顺序比较两个 `Object`阵列。
`static <T extends Comparable<? super T>> int`	`compare(T[] a, T[] b)`	按 `Object`顺序比较两个 `Object`阵列，在可比元素中。
`static <T> int`	`compare(T[] a, T[] b, Comparator<? super T> cmp)`	使用指定的比较器按字典顺序比较两个 `Object`阵列。
`static int`	`compareUnsigned(byte[] a, byte[] b)`	`byte`字典顺序比较两个 `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`数组，将数字按数字处理为无符号。
`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`阵列，将元素数字处理为无符号。
`static int`	`compareUnsigned(short[] a, short[] b)`	`short`字典顺序比较两个 `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, 类<? extends T[]> newType)`	使用空值复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
`static boolean[]`	`copyOfRange(boolean[] original, int from, int to)`	将指定数组的指定范围复制到新数组中。
`static byte[]`	`copyOfRange(byte[] original, int from, int to)`	将指定数组的指定范围复制到新数组中。
`static char[]`	`copyOfRange(char[] original, int from, int to)`	将指定数组的指定范围复制到新数组中。
`static double[]`	`copyOfRange(double[] original, int from, int to)`	将指定数组的指定范围复制到新数组中。
`static float[]`	`copyOfRange(float[] original, int from, int to)`	将指定数组的指定范围复制到新数组中。
`static int[]`	`copyOfRange(int[] original, int from, int to)`	将指定数组的指定范围复制到新数组中。
`static long[]`	`copyOfRange(long[] original, int from, int to)`	将指定数组的指定范围复制到新数组中。
`static short[]`	`copyOfRange(short[] original, int from, int to)`	将指定数组的指定范围复制到新数组中。
`static <T> T[]`	`copyOfRange(T[] original, int from, int to)`	将指定数组的指定范围复制到新数组中。
`static <T,U> T[]`	`copyOfRange(U[] original, int from, int to, 类<? extends T[]> newType)`	将指定数组的指定范围复制到新数组中。
`static boolean`	`deepEquals(Object[] a1, Object[] a2)`	如果两个指定的数组彼此深度相等，则返回 `true` 。
`static int`	`deepHashCode(Object[] a)`	返回基于指定数组的“深层内容”的哈希码。
`static String`	`deepToString(Object[] a)`	返回指定数组的“深层内容”的字符串表示形式。
`static boolean`	`equals(boolean[] a, boolean[] a2)`	如果两个指定的布尔数组彼此相等，则返回 `true` 。
`static boolean`	`equals(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)`	如果两个指定的chars数组在指定范围内彼此相等，则返回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)`	如果两个指定的long数组彼此相等，则返回 `true` 。
`static boolean`	`equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	如果超过指定范围的两个指定的short数组彼此相等，则返回true。
`static boolean`	`equals(short[] a, short[] a2)`	如果两个指定的short数组彼此相等，则返回 `true` 。
`static boolean`	`equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)`	如果在指定范围内指定的两个Object数组彼此相等，则返回true。
`static boolean`	`equals(Object[] a, Object[] a2)`	如果两个指定的Objects数组彼此相等，则返回 `true` 。
`static <T> boolean`	`equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)`	如果在指定范围内指定的两个Object数组彼此相等，则返回true。
`static <T> boolean`	`equals(T[] a, T[] a2, Comparator<? super T> cmp)`	如果两个指定的Objects数组彼此相等，则返回 `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值分配给指定的chars数组的每个元素。
`static void`	`fill(char[] a, int fromIndex, int toIndex, char val)`	将指定的char值分配给指定的chars数组的指定范围的每个元素。
`static void`	`fill(double[] a, double val)`	将指定的double值分配给指定的double数组的每个元素。
`static void`	`fill(double[] a, int fromIndex, int toIndex, double val)`	将指定的double值分配给指定的double数组的指定范围的每个元素。
`static void`	`fill(float[] a, float val)`	将指定的float值分配给指定浮点数组的每个元素。
`static void`	`fill(float[] a, int fromIndex, int toIndex, float val)`	将指定的float值分配给指定浮点数组的指定范围的每个元素。
`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值分配给指定long数组的指定范围的每个元素。
`static void`	`fill(long[] a, long val)`	将指定的long值分配给指定longs数组的每个元素。
`static void`	`fill(short[] a, int fromIndex, int toIndex, short val)`	将指定的short值分配给指定short类数组的指定范围的每个元素。
`static void`	`fill(short[] a, short val)`	为指定的short数组的每个元素指定指定的short值。
`static void`	`fill(Object[] a, int fromIndex, int toIndex, Object val)`	将指定的Object引用分配给指定Object对象的指定范围的每个元素。
`static void`	`fill(Object[] a, Object val)`	将指定的Object引用分配给指定的Objects数组的每个元素。
`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)`	根据元素的natural ordering ，将指定对象数组的指定范围按升序排序。
`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)`	返回指定数组内容的字符串表示形式。

声明方法的类 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 ， 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 ， 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 ， 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 ， 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值的总顺序： -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 ， 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 ， 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值的总订单： -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 ， fromIndex == toIndex排序的范围为空。
    <关系不提供所有双-0.0d == 0.0d值的总顺序： -0.0d == 0.0d是true和Double.NaN值比较任何值都不小于，大于或等于，甚至本身。该方法使用由方法Double.compareTo(java.lang.Double)施加的总顺序： -0.0d被视为小于值0.0d并且Double.NaN被认为大于任何其他值并且所有Double.NaN值被认为是相等的。
    
    Implementation Note:
    
    排序算法是并行排序合并，它将数组分解为自身排序然后合并的子数组。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法对其进行排序。该算法要求工作空间不大于原始数组的指定范围的大小。 ForkJoin common pool用于执行任何并行任务。
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素的索引（包括在内）
    
    toIndex - 要排序的最后一个元素的索引（不包括）
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果是 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static <T extends Comparable<? super T>> void parallelSort(T[] a)
```
    根据元素的natural ordering ，将指定的对象数组按升序排序。阵列中的所有元素都必须实现Comparable接口。此外，阵列中的所有元素都必须是可相互比较 （即， e1.compareTo(e2)不得抛出ClassCastException任何元件e1和e2阵列中）。
    这种保证是稳定的 ：相同的元素不会因排序而重新排序。
    
    Implementation Note:
    
    排序算法是并行排序合并，它将数组分解为自身排序然后合并的子数组。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法对其进行排序。该算法需要的工作空间不大于原始数组的大小。 ForkJoin common pool用于执行任何并行任务。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    异常
    
    ClassCastException - 如果数组包含不可 相互比较的元素（例如，字符串和整数）
    
    IllegalArgumentException - （可选）如果发现数组元素的自然顺序违反了Comparable合同
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static <T extends Comparable<? super T>> void parallelSort(T[] a,
                                                                  int fromIndex,
                                                                  int toIndex)
```
    根据元素的natural ordering ，将指定对象数组的指定范围按升序排序。要排序的范围从索引fromIndex （包括）延伸到索引toIndex （独占）。（如果是fromIndex==toIndex ， fromIndex==toIndex排序的范围为空。）此范围内的所有元素都必须实现Comparable接口。此外，在该范围内的所有元素都必须是可相互比较 （即， e1.compareTo(e2)不得抛出ClassCastException任何元件e1和e2阵列中）。
    这种保证是稳定的 ：相同的元素不会因排序而重新排序。
    
    Implementation Note:
    
    排序算法是并行排序合并，它将数组分解为自身排序然后合并的子数组。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法对其进行排序。该算法要求工作空间不大于原始数组的指定范围的大小。 ForkJoin common pool用于执行任何并行任务。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（包括）的索引
    
    toIndex - 要排序的最后一个元素（不包括）的索引
    
    异常
    
    IllegalArgumentException - 如果发现fromIndex > toIndex或（可选）如果发现数组元素的自然顺序违反了Comparable合同
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
    
    ClassCastException - 如果数组包含不可 相互比较的元素（例如，字符串和整数）。
    
    从以下版本开始：
    
    1.8
  - parallelSort
```
public static <T> void parallelSort(T[] a,
                                    Comparator<? super T> cmp)
```
    根据指定比较器引发的顺序对指定的对象数组进行排序。数组中的所有元素都必须是指定比较相互比较的 （即， c.compare(e1, e2)不得抛出ClassCastException任何元件e1和e2阵列中）。
    这种保证是稳定的 ：相同的元素不会因排序而重新排序。
    
    Implementation Note:
    
    排序算法是并行排序合并，它将数组分解为自身排序然后合并的子数组。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法对其进行排序。该算法需要的工作空间不大于原始数组的大小。 ForkJoin common pool用于执行任何并行任务。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    cmp - 确定数组顺序的比较器。 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 ， fromIndex==toIndex排序的范围为空。）范围内的所有元素必须通过指定的比较器相互比较（即， c.compare(e1, e2)不能为该范围内的任何元素e1和e2抛出ClassCastException ）。
    这种保证是稳定的 ：相同的元素不会因排序而重新排序。
    
    Implementation Note:
    
    排序算法是并行排序合并，它将数组分解为自身排序然后合并的子数组。当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法对其进行排序。该算法要求工作空间不大于原始数组的指定范围的大小。 ForkJoin common pool用于执行任何并行任务。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（包括）的索引
    
    toIndex - 要排序的最后一个元素（不包括）的索引
    
    cmp - 确定数组顺序的比较器。 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阵列中）。
    这种保证是稳定的 ：相同的元素不会因排序而重新排序。
    
    实现注意事项：此实现是一个稳定的，自适应的迭代合并输出，当输入数组部分排序时，需要远远少于n lg（n）的比较，同时在输入数组随机排序时提供传统mergesort的性能。如果输入数组几乎排序，则实现需要大约n次比较。临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用不等。
    
    该实现在其输入数组中具有升序和降序的相同优势，并且可以利用同一输入数组的不同部分中的升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。
    
    该实现改编自Tim Peters的Python排序（ TimSort ）。它使用了Peter McIlroy的“乐观排序和信息理论复杂性”中的技术，参见“第四届年度ACM-SIAM离散算法研讨会论文集”，第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 ， fromIndex==toIndex排序的范围为空。）此范围内的所有元素都必须实现Comparable接口。此外，在该范围内的所有元素都必须是可相互比较 （即， e1.compareTo(e2)不得抛出ClassCastException任何元件e1和e2阵列中）。
    这种保证是稳定的 ：相同的元素不会因排序而重新排序。
    
    实现注意事项：此实现是一个稳定的，自适应的迭代合并输出，当输入数组部分排序时，需要远远少于n lg（n）的比较，同时在输入数组随机排序时提供传统mergesort的性能。如果输入数组几乎排序，则实现需要大约n次比较。临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用不等。
    
    该实现在其输入数组中具有升序和降序的相同优势，并且可以利用同一输入数组的不同部分中的升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。
    
    该实现改编自Tim Peters的Python排序（ TimSort ）。它使用了Peter McIlroy的“乐观排序和信息理论复杂性”中的技术，参见“第四届年度ACM-SIAM离散算法研讨会论文集”，第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阵列中）。
    这种保证是稳定的 ：相同的元素不会因排序而重新排序。
    
    实现注意事项：此实现是一个稳定的，自适应的迭代合并输出，当输入数组部分排序时，需要远远少于n lg（n）的比较，同时在输入数组随机排序时提供传统mergesort的性能。如果输入数组几乎排序，则实现需要大约n次比较。临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用不等。
    
    该实现在其输入数组中具有升序和降序的相同优势，并且可以利用同一输入数组的不同部分中的升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。
    
    该实现改编自Tim Peters的Python排序（ TimSort ）。它使用了Peter McIlroy的“乐观排序和信息理论复杂性”中的技术，参见“第四届年度ACM-SIAM离散算法研讨会论文集”，第467-474页，1993年1月。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    c - 用于确定阵列顺序的比较器。 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 ）。
    这种保证是稳定的 ：相同的元素不会因排序而重新排序。
    
    实现注意事项：此实现是一个稳定的，自适应的迭代合并输出，当输入数组部分排序时，需要远远少于n lg（n）的比较，同时在输入数组随机排序时提供传统mergesort的性能。如果输入数组几乎排序，则实现需要大约n次比较。临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用不等。
    
    该实现在其输入数组中具有升序和降序的相同优势，并且可以利用同一输入数组的不同部分中的升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。
    
    该实现改编自Tim Peters的Python排序（ TimSort ）。它使用了Peter McIlroy的“乐观排序和信息理论复杂性”中的技术，参见“第四届年度ACM-SIAM离散算法研讨会论文集”，第467-474页，1993年1月。
    
    参数类型
    
    T - 要排序的对象的类
    
    参数
    
    a - 要排序的数组
    
    fromIndex - 要排序的第一个元素（包括）的索引
    
    toIndex - 要排序的最后一个元素（不包括）的索引
    
    c - 确定数组顺序的比较器。 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 - 如果指定的数组或函数为null
    
    从以下版本开始：
    
    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 - 如果指定的数组或函数为null
    
    从以下版本开始：
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(long[] array,
                                  LongBinaryOperator op)
```
    使用提供的函数并行地累积给定数组的每个元素。例如，如果数组最初保持[2, 1, 0, 3]并且操作执行添加，则返回时阵列保持[2, 3, 3, 6] 。对于大型数组，并行前缀计算通常比顺序循环更有效。
    
    参数
    
    array - 数组，由此方法就地修改
    
    op - 一种无副作用的关联函数，用于执行累积
    
    异常
    
    NullPointerException - 如果指定的数组或函数为null
    
    从以下版本开始：
    
    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 - 如果指定的数组或函数为null
    
    从以下版本开始：
    
    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 - 如果指定的数组或函数为null
    
    从以下版本开始：
    
    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 - 如果指定的数组或函数为null
    
    从以下版本开始：
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(int[] array,
                                  IntBinaryOperator op)
```
    使用提供的函数并行地累积给定数组的每个元素。例如，如果数组最初保持[2, 1, 0, 3]并且操作执行添加，则返回时阵列保持[2, 3, 3, 6] 。对于大型数组，并行前缀计算通常比顺序循环更有效。
    
    参数
    
    array - 该数组，由此方法就地修改
    
    op - 一种无副作用的关联函数，用于执行累积
    
    异常
    
    NullPointerException - 如果指定的数组或函数为null
    
    从以下版本开始：
    
    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 - 如果指定的数组或函数为null
    
    从以下版本开始：
    
    1.8
  - binarySearch
```
public static int binarySearch(long[] a,
                               long key)
```
    使用二进制搜索算法在指定的long数组中搜索指定的值。在进行此调用之前，必须对数组进行排序（如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)
```
    使用二进制搜索算法在指定的short数组中搜索指定的值。在进行此调用之前，必须对数组进行排序（如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 - 排序数组的比较器。 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 - 用于排序数组的比较器。 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)
```
    如果两个指定的long数组彼此相等，则返回true 。如果两个数组包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中的所有相应元素对是相等的。换句话说，如果两个数组包含相同顺序的相同元素，则它们是相等的。此外，如果两个数组引用都是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则认为两个数组引用相等。
    
    参数
    
    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)
```
    如果两个指定的short数组彼此相等，则返回true 。如果两个数组包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中的所有相应元素对是相等的。换句话说，如果两个数组包含相同顺序的相同元素，则它们是相等的。此外，如果两个数组引用都是null则认为两个数组引用相等。
    
    参数
    
    a - 一个要测试相等性的数组
    
    a2 - 要测试相等性的另一个数组
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(short[] a,
                             int aFromIndex,
                             int aToIndex,
                             short[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果超过指定范围的两个指定的short数组彼此相等，则返回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则认为两个数组引用相等。
    
    参数
    
    a - 要测试相等性的一个数组
    
    a2 - 要测试相等性的另一个数组
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(char[] a,
                             int aFromIndex,
                             int aToIndex,
                             char[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果两个指定的chars数组在指定范围内彼此相等，则返回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则认为两个数组引用相等。
    
    参数
    
    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则认为两个数组引用相等。
    
    参数
    
    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则认为两个数组引用相等。在下列情况下，两个双打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则认为两个数组引用相等。如果f2以下f1 ，则认为两个浮点数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。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对是相等的。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。
    
    如果f2以下f1 ，则认为两个浮点数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)
```
    如果两个指定的Objects数组彼此相等，则返回true 。如果两个数组包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中的所有相应元素对是相等的。如果Objects.equals(e1, e2)则认为两个对象e1和e2 相等。换句话说，如果两个数组包含相同顺序的相同元素，则它们是相等的。此外，如果两个数组引用都是null则认为它们相等。
    
    参数
    
    a - 要测试相等性的一个数组
    
    a2 - 要测试相等性的另一个数组
    
    结果
    
    true如果两个数组相等
  - equals
```
public static boolean equals(Object[] a,
                             int aFromIndex,
                             int aToIndex,
                             Object[] b,
                             int bFromIndex,
                             int bToIndex)
```
    如果在指定范围内指定的两个Object数组彼此相等，则返回true。
    如果每个范围覆盖的元素数量相同，则两个数组被认为是相等的，并且两个数组中指定范围内的所有相应元素对是相等的。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。
    
    如果Objects.equals(e1, e2)则认为两个对象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)
```
    如果两个指定的Objects数组彼此相等，则返回true 。
    如果两个数组包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中的所有相应元素对是相等的。换句话说，如果两个数组包含相同顺序的相同元素，则它们是相等的。此外，如果两个数组引用都是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)
```
    如果在指定范围内指定的两个Object数组彼此相等，则返回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值分配给指定long数组的指定范围的每个元素。要填充的范围从索引延伸fromIndex ，包容，以指数toIndex ，排斥。（如果是fromIndex==toIndex ， fromIndex==toIndex填充的范围为空。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要使用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要使用指定值填充的最后一个元素（不包括）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果是 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(int[] a,
                        int val)
```
    将指定的int值分配给指定的int数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(int[] a,
                        int fromIndex,
                        int toIndex,
                        int val)
```
    将指定的int值分配给指定的int数组的指定范围的每个元素。要填充的范围从索引延伸fromIndex ，包容，以指数toIndex ，排斥。（如果是fromIndex==toIndex ， fromIndex==toIndex填充的范围为空。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要使用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要用指定值填充的最后一个元素（不包括）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(short[] a,
                        short val)
```
    为指定的short数组的每个元素指定指定的short值。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(short[] a,
                        int fromIndex,
                        int toIndex,
                        short val)
```
    将指定的short值分配给指定short类数组的指定范围的每个元素。要填充的范围从索引延伸fromIndex ，包容，以指数toIndex ，排斥。（如果是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值分配给指定的chars数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(char[] a,
                        int fromIndex,
                        int toIndex,
                        char val)
```
    将指定的char值分配给指定的chars数组的指定范围的每个元素。要填充的范围从索引fromIndex （包括）延伸到索引toIndex （独占）。（如果是fromIndex==toIndex ， fromIndex==toIndex填充的范围为空。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要用指定值填充的最后一个元素（不包括）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果是 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(byte[] a,
                        byte val)
```
    将指定的字节值分配给指定字节数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(byte[] a,
                        int fromIndex,
                        int toIndex,
                        byte val)
```
    将指定的字节值分配给指定字节数组的指定范围的每个元素。要填充的范围从索引fromIndex （包括）延伸到索引toIndex （独占）。（如果是fromIndex==toIndex ， 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 ， 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值分配给指定的double数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
  - fill
```
public static void fill(double[] a,
                        int fromIndex,
                        int toIndex,
                        double val)
```
    将指定的double值分配给指定的double数组的指定范围的每个元素。要填充的范围从索引延伸fromIndex ，包容，以指数toIndex ，排斥。（如果是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)
```
    将指定的float值分配给指定浮点数组的指定范围的每个元素。要填充的范围从索引延伸fromIndex ，包容，以指数toIndex ，排斥。（如果是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)
```
    将指定的Object引用分配给指定的Objects数组的每个元素。
    
    参数
    
    a - 要填充的数组
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    ArrayStoreException - 如果指定的值不是可以存储在指定数组中的运行时类型
  - fill
```
public static void fill(Object[] a,
                        int fromIndex,
                        int toIndex,
                        Object val)
```
    将指定的Object引用分配给指定Object对象的指定范围的每个元素。要填充的范围从索引fromIndex （包括）延伸到索引toIndex （独占）。（如果是fromIndex==toIndex ， fromIndex==toIndex填充的范围为空。）
    
    参数
    
    a - 要填充的数组
    
    fromIndex - 要使用指定值填充的第一个元素（包括）的索引
    
    toIndex - 要用指定值填充的最后一个元素（不包括）的索引
    
    val - 要存储在数组的所有元素中的值
    
    异常
    
    IllegalArgumentException - 如果 fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - 如果是 fromIndex < 0或 toIndex > a.length
    
    ArrayStoreException - 如果指定的值不是可以存储在指定数组中的运行时类型
  - copyOf
```
public static <T> T[] copyOf(T[] original,
                             int newLength)
```
    使用空值复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但不在原件中有效的任何索引，副本将包含null 。当且仅当指定的长度大于原始数组的长度时，这些索引才会存在。生成的数组与原始数组完全相同。
    
    参数类型
    
    T - 数组中对象的类
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，用空值截断或填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static <T,U> T[] copyOf(U[] original,
                                     int newLength,
                                     类<? extends T[]> newType)
```
    使用空值复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但不在原件中有效的任何索引，副本将包含null 。当且仅当指定的长度大于原始数组的长度时，这些索引才会存在。结果数组是newType类。
    
    参数类型
    
    U - 原始数组中对象的类
    
    T - 返回数组中的对象类
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    newType - 要返回的副本的类
    
    结果
    
    原始数组的副本，用空值截断或填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    ArrayStoreException - 如果从 original复制的元素不是可以存储在类 newType的数组中的运行时类型
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static byte[] copyOf(byte[] original,
                            int newLength)
```
    使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但不在原件中有效的任何索引，副本将包含(byte)0 。当且仅当指定的长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，用零截断或填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static short[] copyOf(short[] original,
                             int newLength)
```
    使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但不在原件中有效的任何索引，副本将包含(short)0 。当且仅当指定的长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，用零截断或填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static int[] copyOf(int[] original,
                           int newLength)
```
    使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但不在原件中有效的任何索引，副本将包含0 。当且仅当指定的长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，用零截断或填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength是负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static long[] copyOf(long[] original,
                            int newLength)
```
    使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但不在原件中有效的任何索引，副本将包含0L 。当且仅当指定的长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，用零截断或填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static char[] copyOf(char[] original,
                            int newLength)
```
    使用空字符复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但不在原件中有效的任何索引，副本将包含'\\u000' 。当且仅当指定的长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，用空字符截断或填充以获取指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static float[] copyOf(float[] original,
                             int newLength)
```
    使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但不在原件中有效的任何索引，副本将包含0f 。当且仅当指定的长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，用零截断或填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength是负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static double[] copyOf(double[] original,
                              int newLength)
```
    使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但不在原件中有效的任何索引，副本将包含0d 。当且仅当指定的长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，用零截断或填充以获得指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOf
```
public static boolean[] copyOf(boolean[] original,
                               int newLength)
```
    使用false （如有必要）复制指定的数组，截断或填充，以使副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但不在原件中有效的任何索引，副本将包含false 。当且仅当指定的长度大于原始数组的长度时，这些索引才会存在。
    
    参数
    
    original - 要复制的数组
    
    newLength - 要返回的副本的长度
    
    结果
    
    原始数组的副本，用false元素截断或填充以获取指定的长度
    
    异常
    
    NegativeArraySizeException - 如果 newLength为负数
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static <T> T[] copyOfRange(T[] original,
                                  int from,
                                  int to)
```
    将指定数组的指定范围复制到新数组中。范围的初始索引（ from ）必须介于0和original.length之间（包括端点）。 original[from]处的值放入副本的初始元素中（除非from == original.length或from == 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,
                                          类<? extends T[]> newType)
```
    将指定数组的指定范围复制到新数组中。范围的初始索引（ from ）必须介于0和original.length之间（包括0和original.length ）。 original[from]处的值放入副本的初始元素中（除非from == original.length或from == 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 ）必须介于0和original.length之间（包括0和original.length ）。 original[from]处的值放入副本的初始元素中（除非from == original.length或from == 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 ）必须介于0和original.length之间（包括端点）。 original[from]处的值放入副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将放入副本中的后续元素中。范围的最终索引（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， (short)0放置在索引大于或等于original.length - from的副本的所有元素中。返回数组的长度为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，不包括。（此索引可能位于数组之外。）
    
    结果
    
    包含原始数组中指定范围的新数组，用零截断或填充以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果是 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static int[] copyOfRange(int[] original,
                                int from,
                                int to)
```
    将指定数组的指定范围复制到新数组中。范围的初始索引（ from ）必须介于0和original.length之间（包括0和original.length ）。 original[from]处的值放入副本的初始元素中（除非from == original.length或from == 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 ）必须介于0和original.length之间（包括0和original.length ）。 original[from]处的值放入副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将放入副本中的后续元素中。范围的最终指数（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， 0L被放置在索引大于或等于original.length - from的副本的所有元素中。返回数组的长度为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，不包括。（此索引可能位于数组之外。）
    
    结果
    
    包含原始数组中指定范围的新数组，用零截断或填充以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果是 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static char[] copyOfRange(char[] original,
                                 int from,
                                 int to)
```
    将指定数组的指定范围复制到新数组中。范围的初始索引（ from ）必须介于0和original.length之间（包括端点）。 original[from]处的值放入副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将放入副本中的后续元素中。范围的最终索引（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， '\\u000'放置在索引大于或等于original.length - from的副本的所有元素中。返回数组的长度为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，不包括。（此索引可能位于数组之外。）
    
    结果
    
    包含原始数组中指定范围的新数组，截断或填充空字符以获取所需长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果是 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - copyOfRange
```
public static float[] copyOfRange(float[] original,
                                  int from,
                                  int to)
```
    将指定数组的指定范围复制到新数组中。范围的初始索引（ from ）必须介于0和original.length之间（包括0和original.length ）。 original[from]处的值放入副本的初始元素中（除非from == original.length或from == 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 ）必须介于0和original.length之间（包括0和original.length ）。 original[from]处的值放入副本的初始元素中（除非from == original.length或from == 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 ）必须介于0和original.length之间（包括端点）。 original[from]处的值放入副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将放入副本中的后续元素中。范围的最终指数（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， false被放置在索引大于或等于original.length - from的副本的所有元素中。返回数组的长度为to - from 。
    
    参数
    
    original - 要从中复制范围的数组
    
    from - 要复制的范围的初始索引（包括）
    
    to - 要复制的范围的最终索引，不包括。（此索引可能位于数组之外。）
    
    结果
    
    包含原始数组中指定范围的新数组，使用false元素截断或填充以获取所需长度
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果是 from < 0或 from > original.length
    
    IllegalArgumentException - 如果 from > to
    
    NullPointerException - 如果 original为空
    
    从以下版本开始：
    
    1.6
  - asList
```
@SafeVarargs
public static <T> List<T> asList(T... a)
```
    返回由指定数组支持的固定大小的列表。（对返回列表的更改“直写”到数组。）此方法与Collection.toArray()结合使用，作为基于数组和基于集合的API之间的桥梁。返回的列表是可序列化的并且实现了RandomAccess 。
    此方法还提供了一种方便的方法来创建初始化为包含多个元素的固定大小的列表：
    
    List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
    参数类型
    
    T - 数组中对象的类
    
    参数
    
    a - 将用于备份列表的阵列
    
    结果
    
    指定数组的列表视图
  - hashCode
```
public static int hashCode(long[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个long阵列a和b这样的Arrays.equals(a, b) ，它也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Long个实例表示的元素a以相同的顺序。如果a是null ，则此方法返回0。
    
    参数
    
    a - 要计算其哈希值的数组
    
    结果
    
    基于内容的哈希码，用于 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(int[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个非空int阵列a和b这样的Arrays.equals(a, b) ，它也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Integer个实例表示的元素a以相同的顺序。如果a是null ，则此方法返回0。
    
    参数
    
    a - 要计算其哈希值的数组
    
    结果
    
    基于内容的哈希代码，用于 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(short[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个short阵列a和b这样的Arrays.equals(a, b) ，它也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Short个实例表示的元素a以相同的顺序。如果a是null ，则此方法返回0。
    
    参数
    
    a - 要计算其哈希值的数组
    
    结果
    
    基于内容的哈希代码，用于 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(char[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个char阵列a和b这样的Arrays.equals(a, b) ，它也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Character个实例表示的元素a以相同的顺序。如果a是null ，则此方法返回0。
    
    参数
    
    a - 要计算其哈希值的数组
    
    结果
    
    基于内容的哈希码，用于 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(byte[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个byte阵列a和b这样的Arrays.equals(a, b) ，它也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Byte个实例表示的元素a以相同的顺序。如果a是null ，则此方法返回0。
    
    参数
    
    a - 要计算其哈希值的数组
    
    结果
    
    基于内容的哈希码，用于 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(boolean[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个boolean阵列a和b这样的Arrays.equals(a, b) ，它也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Boolean个实例表示的元素a以相同的顺序。如果a是null ，则此方法返回0。
    
    参数
    
    a - 要计算其哈希值的数组
    
    结果
    
    基于内容的哈希码，用于 a
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(float[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个float阵列a和b这样的Arrays.equals(a, b) ，它也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Float个实例表示的元素a以相同的顺序。如果a是null ，则此方法返回0。
    
    参数
    
    a - 要计算其哈希值的数组
    
    结果
    
    a的基于内容的哈希码
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(double[] a)
```
    根据指定数组的内容返回哈希码。对于任何两个double阵列a和b这样的Arrays.equals(a, b) ，情况也是Arrays.hashCode(a) == Arrays.hashCode(b) 。
    通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Double个实例表示的元素a以相同的顺序。如果a是null ，则此方法返回0。
    
    参数
    
    a - 要计算其哈希值的数组
    
    结果
    
    a的基于内容的哈希码
    
    从以下版本开始：
    
    1.5
  - hashCode
```
public static int hashCode(Object[] a)
```
    根据指定数组的内容返回哈希码。如果数组包含其他数组作为元素，则哈希代码基于其身份而不是其内容。因此，可以直接或间接通过一个或多个级别的数组在包含自身作为元素的数组上调用此方法。
    对于任何两个阵列a和b这样的Arrays.equals(a, b) ，也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
    
    此方法返回的值等于Arrays.asList(a).hashCode()返回的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是基本类型的数组，或者如果e是引用类型的数组则通过递归调用Arrays.deepHashCode(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()返回的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 - 如果生成器为null
    
    从以下版本开始：
    
    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 - 如果生成器为null
    
    从以下版本开始：
    
    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 - 如果生成器为null
    
    从以下版本开始：
    
    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 - 如果生成器为null
    
    从以下版本开始：
    
    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 - 如果生成器为null
    
    从以下版本开始：
    
    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 - 如果生成器为null
    
    从以下版本开始：
    
    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 - 如果生成器为null
    
    从以下版本开始：
    
    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 - 如果生成器为null
    
    从以下版本开始：
    
    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 - 索引立即覆盖最后一个索引
    
    结果
    
    a阵列范围为 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 - 索引立即覆盖最后一个索引
    
    结果
    
    a阵列范围为 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[])。）
    
    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[])。）
    
    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
    
    从以下版本开始：
    
    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[])。）
    
    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.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 - 如果任一数组为null
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(short[] a,
                          short[] b)
```
    short字典顺序比较两个short阵列。
    如果两个数组共享一个公共前缀，则字典比较是比较两个元素的结果，如同通过Short.compare(short, short) ，在相应数组中作为前缀长度的索引。否则，一个数组是另一个数组的正确前缀，并且词典比较是比较两个数组长度的结果。（有关通用和正确前缀的定义，请参阅mismatch(short[], short[])。）
    
    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.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阵列，数字处理元素为无符号。
    如果两个数组共享一个公共前缀，则字典比较是比较两个元素的结果，如同通过Short.compareUnsigned(short, short) ，在相应数组中作为前缀长度的索引处。否则，一个数组是另一个数组的正确前缀，并且词典比较是比较两个数组长度的结果。（有关通用和正确前缀的定义，请参阅mismatch(short[], short[])。）
    
    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.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 - 如果任一数组为null
    
    从以下版本开始：
    
    9
  - compare
```
public static int compare(char[] a,
                          char[] b)
```
    char字典顺序比较两个char阵列。
    如果两个数组共享一个公共前缀，则字典比较是比较两个元素的结果，如同通过Character.compare(char, char) ，在相应数组中作为前缀长度的索引。否则，一个数组是另一个数组的正确前缀，并且词典比较是比较两个数组长度的结果。（有关通用和正确前缀的定义，请参阅mismatch(char[], char[])。）
    
    甲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阵列。
    如果超过指定范围的两个数组共享一个公共前缀，则字典比较是比较两个元素的结果，如同通过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[])。）
    
    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字典顺序比较两个int阵列，数字处理元素为无符号。
    如果两个数组共享一个公共前缀，则字典比较是比较两个元素的结果，就好像是通过Integer.compareUnsigned(int, int) ，在相应数组中作为前缀长度的索引处。否则，一个数组是另一个数组的正确前缀，并且词典比较是比较两个数组长度的结果。（有关通用和正确前缀的定义，请参阅mismatch(int[], int[])。）
    
    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阵列，将元素数字处理为无符号。
    如果超过指定范围的两个数组共享一个公共前缀，则字典比较是比较两个元素的结果，如同通过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 - 如果任一数组为null
    
    从以下版本开始：
    
    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.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阵列，数字处理元素为无符号。
    如果两个数组共享一个公共前缀，则字典比较是比较两个元素的结果，就好像是通过Long.compareUnsigned(long, long) ，在相应数组中作为前缀长度的索引处。否则，一个数组是另一个数组的正确前缀，并且词典比较是比较两个数组长度的结果。（有关通用和正确前缀的定义，请参阅mismatch(long[], long[])。）
    
    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.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 - 如果任一数组为null
    
    从以下版本开始：
    
    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[])。）
    
    甲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顺序比较两个Object阵列，在可比元素中。
    如果两个数组共享一个公共前缀，则字典比较是在相应数组中作为前缀长度的索引i处比较两个类型为T元素的结果，如下所示：
    
    Comparator.nullsFirst(Comparator.<T>naturalOrder()). compare(a[i], b[i])
    否则，一个数组是另一个数组的正确前缀，并且词典比较是比较两个数组长度的结果。（有关通用和正确前缀的定义，请参阅mismatch(Object[], Object[])。）
    甲null数组引用被认为比字典序非少null数组引用。两个null数组引用被认为是相等的。 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[])。）
    
    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 ）分别共享一个适当如果满足下列表达式为真：
    
    (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

方法摘要

声明方法的类 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