模块 java.base

包 java.util

类 Arrays

java.lang.Object

java.util.Arrays

public class Arrays extends Object 
      

此类包含用于操作数组（例如排序和搜索）的各种方法。此类还包含一个允许将数组视为列表的静态工厂。

如果指定的数组引用为空，则此类中的方法都会抛出 NullPointerException ，除非另有说明。

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

此类是 Java 集合框架 的成员。

自从：

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)	使用二进制搜索算法在指定的整数数组中搜索指定的值。
static int	binarySearch(int[] a, int fromIndex, int toIndex, int key)	使用二进制搜索算法在指定的整数数组范围内搜索指定值。
static int	binarySearch(long[] a, int fromIndex, int toIndex, long key)	使用二进制搜索算法在指定的 long 数组范围内搜索指定值。
static int	binarySearch(long[] a, long key)	使用二进制搜索算法在指定的 longs 数组中搜索指定的值。
static int	binarySearch(short[] a, int fromIndex, int toIndex, short key)	使用二进制搜索算法搜索指定值的指定值数组的范围。
static int	binarySearch(short[] a, short key)	使用二进制搜索算法在指定的 shorts 数组中搜索指定的值。
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 数组。
static int	compare(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 boolean 数组。
static int	compare(byte[] a, byte[] b)	按字典顺序比较两个 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 数组。
static int	compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 char 数组。
static int	compare(double[] a, double[] b)	按字典顺序比较两个 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 数组。
static int	compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 float 数组。
static int	compare(int[] a, int[] b)	按字典顺序比较两个 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 数组。
static int	compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 short 数组。
static int	compare(short[] a, short[] b)	按字典顺序比较两个 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 数组。
static <T> int	compare(T[] a, T[] b, Comparator<? super T> cmp)	使用指定的比较器按字典顺序比较两个 Object 数组。
static int	compareUnsigned(byte[] a, byte[] b)	按字典顺序比较两个 byte 数组，在数字上将元素视为无符号。
static int	compareUnsigned(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 byte 数组，在数字上将元素视为无符号。
static int	compareUnsigned(int[] a, int[] b)	按字典顺序比较两个 int 数组，在数字上将元素视为无符号。
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 数组，在数字上将元素视为无符号。
static int	compareUnsigned(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 short 数组，在数字上将元素视为无符号。
static int	compareUnsigned(short[] a, short[] b)	按字典顺序比较两个 short 数组，在数字上将元素视为无符号。
static boolean[]	copyOf(boolean[] original, int newLength)	复制指定的数组，用 false 截断或填充（如有必要），以便副本具有指定的长度。
static byte[]	copyOf(byte[] original, int newLength)	复制指定的数组，用零截断或填充（如有必要），使副本具有指定的长度。
static char[]	copyOf(char[] original, int newLength)	复制指定的数组，用空字符截断或填充（如有必要），使副本具有指定的长度。
static double[]	copyOf(double[] original, int newLength)	复制指定的数组，用零截断或填充（如有必要），使副本具有指定的长度。
static float[]	copyOf(float[] original, int newLength)	复制指定的数组，用零截断或填充（如有必要），使副本具有指定的长度。
static int[]	copyOf(int[] original, int newLength)	复制指定的数组，用零截断或填充（如有必要），使副本具有指定的长度。
static long[]	copyOf(long[] original, int newLength)	复制指定的数组，用零截断或填充（如有必要），使副本具有指定的长度。
static short[]	copyOf(short[] original, int newLength)	复制指定的数组，用零截断或填充（如有必要），使副本具有指定的长度。
static <T> T[]	copyOf(T[] original, int newLength)	复制指定的数组，用空值截断或填充（如有必要），以便副本具有指定的长度。
static <T, U> T[]	copyOf(U[] original, int newLength, Class<? extends T[]> newType)	复制指定的数组，用空值截断或填充（如有必要），以便副本具有指定的长度。
static boolean[]	copyOfRange(boolean[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static byte[]	copyOfRange(byte[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static char[]	copyOfRange(char[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static double[]	copyOfRange(double[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static float[]	copyOfRange(float[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static int[]	copyOfRange(int[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static long[]	copyOfRange(long[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static short[]	copyOfRange(short[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static <T> T[]	copyOfRange(T[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static <T, U> T[]	copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)	将指定数组的指定范围复制到新数组中。
static boolean	deepEquals(Object[] a1, Object[] a2)	如果两个指定的数组是，则返回 true深深地平等彼此。
static int	deepHashCode(Object[] a)	返回基于指定数组的“深层内容”的哈希码。
static String	deepToString(Object[] a)	返回指定数组的“深层内容”的字符串表示形式。
static boolean	equals(boolean[] a, boolean[] a2)	如果两个指定的布尔数组是，则返回 trueequal彼此。
static boolean	equals(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定的布尔数组是equal彼此。
static boolean	equals(byte[] a, byte[] a2)	如果两个指定的字节数组是，则返回 trueequal彼此。
static boolean	equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定字节数组是equal彼此。
static boolean	equals(char[] a, char[] a2)	如果两个指定的字符数组是，则返回 trueequal彼此。
static boolean	equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定字符数组是equal彼此。
static boolean	equals(double[] a, double[] a2)	如果两个指定的双精度数组是，则返回 trueequal彼此。
static boolean	equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定双精度数组是equal彼此。
static boolean	equals(float[] a, float[] a2)	如果两个指定的浮点数数组是，则返回 trueequal彼此。
static boolean	equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定浮点数数组是equal彼此。
static boolean	equals(int[] a, int[] a2)	如果两个指定的整数数组是，则返回 trueequal彼此。
static boolean	equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定整数数组是equal彼此。
static boolean	equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)	如果在指定范围内的两个指定的 longs 数组是equal彼此。
static boolean	equals(long[] a, long[] a2)	如果两个指定的 long 数组是，则返回 trueequal彼此。
static boolean	equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定短裤数组是equal彼此。
static boolean	equals(short[] a, short[] a2)	如果两个指定的短裤数组是，则返回 trueequal彼此。
static boolean	equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定对象数组是equal彼此。
static boolean	equals(Object[] a, Object[] a2)	如果两个指定的对象数组是返回 trueequal彼此。
static <T> boolean	equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)	如果指定范围内的两个指定对象数组是equal彼此。
static <T> boolean	equals(T[] a, T[] a2, Comparator<? super T> cmp)	如果两个指定的对象数组是返回 trueequal彼此。
static void	fill(boolean[] a, boolean val)	将指定的boolean分配给指定的布尔数组的每个元素。
static void	fill(boolean[] a, int fromIndex, int toIndex, boolean val)	将指定的boolean分配给指定布尔数组的指定范围内的每个元素。
static void	fill(byte[] a, byte val)	将指定字节值分配给指定字节数组的每个元素。
static void	fill(byte[] a, int fromIndex, int toIndex, byte val)	将指定字节值分配给指定字节数组的指定范围内的每个元素。
static void	fill(char[] a, char val)	将指定的 char 值分配给指定的 char 数组的每个元素。
static void	fill(char[] a, int fromIndex, int toIndex, char val)	将指定的 char 值分配给指定字符数组的指定范围内的每个元素。
static void	fill(double[] a, double val)	将指定的双精度值分配给指定双精度数组的每个元素。
static void	fill(double[] a, int fromIndex, int toIndex, double val)	将指定的双精度值分配给指定双精度数组的指定范围内的每个元素。
static void	fill(float[] a, float val)	将指定的浮点值分配给指定的浮点数组的每个元素。
static void	fill(float[] a, int fromIndex, int toIndex, float val)	将指定的浮点值分配给指定浮点数数组的指定范围内的每个元素。
static void	fill(int[] a, int val)	将指定的 int 值分配给指定的 int 数组的每个元素。
static void	fill(int[] a, int fromIndex, int toIndex, int val)	将指定的 int 值分配给指定 int 数组的指定范围内的每个元素。
static void	fill(long[] a, int fromIndex, int toIndex, long val)	将指定的 long 值分配给指定 long 数组的指定范围内的每个元素。
static void	fill(long[] a, long val)	将指定的 long 值分配给指定的 long 数组的每个元素。
static void	fill(short[] a, int fromIndex, int toIndex, short val)	将指定的短整型值分配给指定短整型数组的指定范围内的每个元素。
static void	fill(short[] a, short val)	将指定的 short 值分配给指定的 short 数组的每个元素。
static void	fill(Object[] a, int fromIndex, int toIndex, Object val)	将指定的对象引用分配给指定对象数组的指定范围内的每个元素。
static void	fill(Object[] a, Object val)	将指定的对象引用分配给指定对象数组的每个元素。
static int	hashCode(boolean[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(byte[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(char[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(double[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(float[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(int[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(long[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(short[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(Object[] a)	根据指定数组的内容返回哈希码。
static int	mismatch(boolean[] a, boolean[] b)	查找并返回两个 boolean 数组之间第一个不匹配的索引，否则如果未找到不匹配则返回 -1。
static int	mismatch(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 boolean 数组之间第一个不匹配项的相对索引，否则如果未找到不匹配项，则返回 -1。
static int	mismatch(byte[] a, byte[] b)	查找并返回两个 byte 数组之间第一个不匹配的索引，否则如果未找到不匹配则返回 -1。
static int	mismatch(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 byte 数组之间第一个不匹配项的相对索引，否则如果未找到不匹配项，则返回 -1。
static int	mismatch(char[] a, char[] b)	查找并返回两个 char 数组之间第一个不匹配的索引，否则如果未找到不匹配则返回 -1。
static int	mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 char 数组之间第一个不匹配项的相对索引，否则如果未找到不匹配项，则返回 -1。
static int	mismatch(double[] a, double[] b)	查找并返回两个 double 数组之间第一个不匹配的索引，否则如果未找到不匹配则返回 -1。
static int	mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 double 数组之间第一个不匹配项的相对索引，否则如果未找到不匹配项，则返回 -1。
static int	mismatch(float[] a, float[] b)	查找并返回两个 float 数组之间第一个不匹配的索引，否则如果未找到不匹配则返回 -1。
static int	mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 float 数组之间第一个不匹配项的相对索引，否则如果未找到不匹配项，则返回 -1。
static int	mismatch(int[] a, int[] b)	查找并返回两个 int 数组之间第一个不匹配的索引，否则如果未找到不匹配则返回 -1。
static int	mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 int 数组之间第一个不匹配项的相对索引，否则如果未找到不匹配项，则返回 -1。
static int	mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 long 数组之间第一个不匹配项的相对索引，否则如果未找到不匹配项，则返回 -1。
static int	mismatch(long[] a, long[] b)	查找并返回两个 long 数组之间第一个不匹配的索引，否则如果未找到不匹配则返回 -1。
static int	mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 short 数组之间第一个不匹配项的相对索引，否则如果未找到不匹配项，则返回 -1。
static int	mismatch(short[] a, short[] b)	查找并返回两个 short 数组之间第一个不匹配的索引，否则如果未找到不匹配则返回 -1。
static int	mismatch(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 Object 数组之间第一个不匹配项的相对索引，否则如果未找到不匹配项，则返回 -1。
static int	mismatch(Object[] a, Object[] b)	查找并返回两个 Object 数组之间第一个不匹配的索引，否则如果未找到不匹配则返回 -1。
static <T> int	mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)	查找并返回指定范围内两个 Object 数组之间第一个不匹配项的相对索引，否则如果未找到不匹配项，则返回 -1。
static <T> int	mismatch(T[] a, T[] b, Comparator<? super T> cmp)	查找并返回两个 Object 数组之间第一个不匹配的索引，否则如果未找到不匹配则返回 -1。
static void	parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)	对数组的给定子范围执行 parallelPrefix(double[], DoubleBinaryOperator) 。
static void	parallelPrefix(double[] array, DoubleBinaryOperator op)	使用提供的函数并行地累积给定数组的每个元素。
static void	parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)	对数组的给定子范围执行 parallelPrefix(int[], IntBinaryOperator) 。
static void	parallelPrefix(int[] array, IntBinaryOperator op)	使用提供的函数并行地累积给定数组的每个元素。
static void	parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)	对数组的给定子范围执行 parallelPrefix(long[], LongBinaryOperator) 。
static void	parallelPrefix(long[] array, LongBinaryOperator op)	使用提供的函数并行地累积给定数组的每个元素。
static <T> void	parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)	对数组的给定子范围执行 parallelPrefix(Object[], BinaryOperator) 。
static <T> void	parallelPrefix(T[] array, BinaryOperator<T> op)	使用提供的函数并行地累积给定数组的每个元素。
static void	parallelSetAll(double[] array, IntToDoubleFunction generator)	并行设置指定数组的所有元素，使用提供的生成器函数计算每个元素。
static void	parallelSetAll(int[] array, IntUnaryOperator generator)	并行设置指定数组的所有元素，使用提供的生成器函数计算每个元素。
static void	parallelSetAll(long[] array, IntToLongFunction generator)	并行设置指定数组的所有元素，使用提供的生成器函数计算每个元素。
static <T> void	parallelSetAll(T[] array, IntFunction<? extends T> generator)	并行设置指定数组的所有元素，使用提供的生成器函数计算每个元素。
static void	parallelSort(byte[] a)	将指定的数组按数字升序排序。
static void	parallelSort(byte[] a, int fromIndex, int toIndex)	将数组的指定范围按数字升序排序。
static void	parallelSort(char[] a)	将指定的数组按数字升序排序。
static void	parallelSort(char[] a, int fromIndex, int toIndex)	将数组的指定范围按数字升序排序。
static void	parallelSort(double[] a)	将指定的数组按数字升序排序。
static void	parallelSort(double[] a, int fromIndex, int toIndex)	将数组的指定范围按数字升序排序。
static void	parallelSort(float[] a)	将指定的数组按数字升序排序。
static void	parallelSort(float[] a, int fromIndex, int toIndex)	将数组的指定范围按数字升序排序。
static void	parallelSort(int[] a)	将指定的数组按数字升序排序。
static void	parallelSort(int[] a, int fromIndex, int toIndex)	将数组的指定范围按数字升序排序。
static void	parallelSort(long[] a)	将指定的数组按数字升序排序。
static void	parallelSort(long[] a, int fromIndex, int toIndex)	将数组的指定范围按数字升序排序。
static void	parallelSort(short[] a)	将指定的数组按数字升序排序。
static void	parallelSort(short[] a, int fromIndex, int toIndex)	将数组的指定范围按数字升序排序。
static <T extends Comparable<? super T>> void	parallelSort(T[] a)	根据其元素的 自然排序 将指定的对象数组按升序排序。
static <T extends Comparable<? super T>> void	parallelSort(T[] a, int fromIndex, int toIndex)	根据其元素的自然排序，将指定对象数组的指定范围按升序排序。
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)	根据其元素的 自然排序 将指定的对象数组按升序排序。
static void	sort(Object[] a, int fromIndex, int toIndex)	根据其元素的自然排序，将指定对象数组的指定范围按升序排序。
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)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

sort

public static void sort(int[] a, int fromIndex, int toIndex)
            

将数组的指定范围按升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

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)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

sort

public static void sort(long[] a, int fromIndex, int toIndex)
            

将数组的指定范围按升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

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)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

sort

public static void sort(short[] a, int fromIndex, int toIndex)
            

将数组的指定范围按升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

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)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

sort

public static void sort(char[] a, int fromIndex, int toIndex)
            

将数组的指定范围按升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

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)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

sort

public static void sort(byte[] a, int fromIndex, int toIndex)
            

将数组的指定范围按升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

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)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

sort

public static void sort(float[] a, int fromIndex, int toIndex)
            

将数组的指定范围按升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

< 关系不提供所有浮点值的总顺序：-0.0f == 0.0f 是 true 和 Float.NaN 值比较既不小于、大于也不等于任何值，甚至它本身。此方法使用方法 Float.compareTo(java.lang.Float) 施加的总顺序：-0.0f 被视为小于值 0.0f，Float.NaN 被视为大于任何其他值，所有 Float.NaN 值被视为相等。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

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)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

sort

public static void sort(double[] a, int fromIndex, int toIndex)
            

将数组的指定范围按升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

< 关系不提供所有双精度值的总顺序：-0.0d == 0.0d 是 true 和 Double.NaN 值比较既不小于、大于也不等于任何值，甚至它本身。此方法使用方法 Double.compareTo(java.lang.Double) 施加的总顺序：-0.0d 被视为小于值 0.0d，Double.NaN 被视为大于任何其他值，所有 Double.NaN 值被视为相等。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

fromIndex - 要排序的第一个元素的索引，包括在内

toIndex - 要排序的最后一个元素的索引，独占的

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

parallelSort

public static void parallelSort(byte[] a)
            

将指定的数组按数字升序排序。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

自从：

1.8

parallelSort

public static void parallelSort(byte[] a, int fromIndex, int toIndex)
            

将数组的指定范围按数字升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

fromIndex - 要排序的第一个元素的索引，包括在内

toIndex - 要排序的最后一个元素的索引，独占的

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

自从：

1.8

parallelSort

public static void parallelSort(char[] a)
            

将指定的数组按数字升序排序。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

自从：

1.8

parallelSort

public static void parallelSort(char[] a, int fromIndex, int toIndex)
            

将数组的指定范围按数字升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

fromIndex - 要排序的第一个元素的索引，包括在内

toIndex - 要排序的最后一个元素的索引，独占的

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

自从：

1.8

parallelSort

public static void parallelSort(short[] a)
            

将指定的数组按数字升序排序。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

自从：

1.8

parallelSort

public static void parallelSort(short[] a, int fromIndex, int toIndex)
            

将数组的指定范围按数字升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

fromIndex - 要排序的第一个元素的索引，包括在内

toIndex - 要排序的最后一个元素的索引，独占的

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

自从：

1.8

parallelSort

public static void parallelSort(int[] a)
            

将指定的数组按数字升序排序。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

自从：

1.8

parallelSort

public static void parallelSort(int[] a, int fromIndex, int toIndex)
            

将数组的指定范围按数字升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

fromIndex - 要排序的第一个元素的索引，包括在内

toIndex - 要排序的最后一个元素的索引，独占的

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

自从：

1.8

parallelSort

public static void parallelSort(long[] a)
            

将指定的数组按数字升序排序。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

自从：

1.8

parallelSort

public static void parallelSort(long[] a, int fromIndex, int toIndex)
            

将数组的指定范围按数字升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

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 值被视为相等。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

自从：

1.8

parallelSort

public static void parallelSort(float[] a, int fromIndex, int toIndex)
            

将数组的指定范围按数字升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

< 关系不提供所有浮点值的总顺序：-0.0f == 0.0f 是 true 和 Float.NaN 值比较既不小于、大于也不等于任何值，甚至它本身。此方法使用方法 Float.compareTo(java.lang.Float) 施加的总顺序：-0.0f 被视为小于值 0.0f，Float.NaN 被视为大于任何其他值，所有 Float.NaN 值被视为相等。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

fromIndex - 要排序的第一个元素的索引，包括在内

toIndex - 要排序的最后一个元素的索引，独占的

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

自从：

1.8

parallelSort

public static void parallelSort(double[] a)
            

将指定的数组按数字升序排序。

< 关系不提供所有双精度值的总顺序：-0.0d == 0.0d 是 true 和 Double.NaN 值比较既不小于、大于也不等于任何值，甚至它本身。此方法使用方法 Double.compareTo(java.lang.Double) 施加的总顺序：-0.0d 被视为小于值 0.0d，Double.NaN 被视为大于任何其他值，所有 Double.NaN 值被视为相等。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

a - 要排序的数组

自从：

1.8

parallelSort

public static void parallelSort(double[] a, int fromIndex, int toIndex)
            

将数组的指定范围按数字升序排序。要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。如果 fromIndex == toIndex ，则要排序的范围为空。

< 关系不提供所有双精度值的总顺序：-0.0d == 0.0d 是 true 和 Double.NaN 值比较既不小于、大于也不等于任何值，甚至它本身。此方法使用方法 Double.compareTo(java.lang.Double) 施加的总顺序：-0.0d 被视为小于值 0.0d，Double.NaN 被视为大于任何其他值，所有 Double.NaN 值被视为相等。

实现注意事项：

排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Josh Bloch 的双轴快速排序。该算法在所有数据集上提供 O(n log(n)) 性能，并且通常比传统（单轴）快速排序实现更快。

参数：

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)
            

根据其元素的 自然排序 将指定的对象数组按升序排序。数组中的所有元素都必须实现 Comparable 接口。此外，数组中的所有元素必须是相互比较（也就是说，e1.compareTo(e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。

这种类型保证是稳定的: 相等的元素不会因排序而重新排序。

实现注意事项：

排序算法是一种并行排序合并，它将数组分解为子数组，这些子数组本身已排序然后合并。当子数组长度达到最小粒度时，使用适当的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)
            

根据其元素的自然排序，将指定对象数组的指定范围按升序排序。要排序的范围从索引 fromIndex 延伸到索引 toIndex ，不包括在内。 （如果 fromIndex==toIndex ，则要排序的范围为空。）此范围内的所有元素都必须实现 Comparable 接口。此外，该范围内的所有元素必须相互比较（也就是说，e1.compareTo(e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。

这种类型保证是稳定的: 相等的元素不会因排序而重新排序。

实现注意事项：

排序算法是一种并行排序合并，它将数组分解为子数组，这些子数组本身已排序然后合并。当子数组长度达到最小粒度时，使用适当的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) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。

这种类型保证是稳定的: 相等的元素不会因排序而重新排序。

实现注意事项：

排序算法是一种并行排序合并，它将数组分解为子数组，这些子数组本身已排序然后合并。当子数组长度达到最小粒度时，使用适当的Arrays.sort 方法对子数组进行排序。如果指定数组的长度小于最小粒度，则使用适当的 Arrays.sort 方法对其进行排序。该算法要求工作空间不大于原始数组的大小。 ForkJoin common pool 用于执行任何并行任务。

类型参数：

T - 要排序的对象的类

参数：

a - 要排序的数组

cmp - 确定数组顺序的比较器。 null 值表示应使用元素的 自然排序。

抛出：

ClassCastException - 如果数组包含的元素不是相互比较使用指定的比较器

IllegalArgumentException - （可选）如果发现比较器违反了 Comparator 合同

自从：

1.8

parallelSort

public static <T> void parallelSort(T[] a, int fromIndex, int toIndex, Comparator <? super T> cmp)
            

根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。要排序的范围从索引 fromIndex 延伸到索引 toIndex ，不包括在内。 （如果 fromIndex==toIndex ，则要排序的范围为空。）范围内的所有元素必须是相互比较由指定的比较器（即，c.compare(e1, e2) 不得为范围内的任何元素 e1 和 e2 抛出 ClassCastException）。

这种类型保证是稳定的: 相等的元素不会因排序而重新排序。

实现注意事项：

排序算法是一种并行排序合并，它将数组分解为子数组，这些子数组本身已排序然后合并。当子数组长度达到最小粒度时，使用适当的Arrays.sort 方法对子数组进行排序。如果指定数组的长度小于最小粒度，则使用适当的 Arrays.sort 方法对其进行排序。该算法要求工作空间不大于原始数组指定范围的大小。 ForkJoin common pool 用于执行任何并行任务。

类型参数：

T - 要排序的对象的类

参数：

a - 要排序的数组

fromIndex - 要排序的第一个元素（包括）的索引

toIndex - 要排序的最后一个元素（不包括）的索引

cmp - 确定数组顺序的比较器。 null 值表示应使用元素的 自然排序。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex 或（可选）如果发现数组元素的自然排序违反了 Comparable 约定

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

ClassCastException - 如果数组包含的元素不是相互比较（例如，字符串和整数）。

自从：

1.8

sort

public static void sort(Object [] a)
            

根据其元素的 自然排序 将指定的对象数组按升序排序。数组中的所有元素都必须实现 Comparable 接口。此外，数组中的所有元素必须是相互比较（也就是说，e1.compareTo(e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。

这种类型保证是稳定的: 相等的元素不会因排序而重新排序。

实现注意事项：此实现是一种稳定的、自适应的、迭代的合并排序，当输入数组部分排序时需要的比较少于 n lg(n) 次，同时在输入数组随机排序时提供传统合并排序的性能。如果输入数组几乎已排序，则实现需要大约 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)
            

根据其元素的自然排序，将指定对象数组的指定范围按升序排序。要排序的范围从索引 fromIndex 延伸到索引 toIndex ，不包括在内。 （如果 fromIndex==toIndex ，则要排序的范围为空。）此范围内的所有元素都必须实现 Comparable 接口。此外，该范围内的所有元素必须相互比较（也就是说，e1.compareTo(e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。

这种类型保证是稳定的: 相等的元素不会因排序而重新排序。

实现注意事项：此实现是一种稳定的、自适应的、迭代的合并排序，当输入数组部分排序时需要的比较少于 n lg(n) 次，同时在输入数组随机排序时提供传统合并排序的性能。如果输入数组几乎已排序，则实现需要大约 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) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。

这种类型保证是稳定的: 相等的元素不会因排序而重新排序。

实现注意事项：此实现是一种稳定的、自适应的、迭代的合并排序，当输入数组部分排序时需要的比较少于 n lg(n) 次，同时在输入数组随机排序时提供传统合并排序的性能。如果输入数组几乎已排序，则实现需要大约 n 次比较。临时存储要求从用于几乎排序的输入数组的小常量到用于随机排序的输入数组的 n/2 对象引用不等。

该实现在其输入数组中同样利用升序和降序，并且可以在同一输入数组的不同部分利用升序和降序。它非常适合合并两个或多个排序的数组：简单地连接数组并对结果数组进行排序。

该实现适配自 Tim Peters 的 Python 列表排序 ( TimSort)。它使用了 Peter McIlroy 的“乐观排序和信息理论复杂性”中的技术，在第四届年度 ACM-SIAM 离散算法研讨会论文集中，第 467-474 页，1993 年 1 月。

类型参数：

T - 要排序的对象的类

参数：

a - 要排序的数组

c - 确定数组顺序的比较器。 null 值表示应使用元素的 自然排序。

抛出：

ClassCastException - 如果数组包含的元素不是相互比较使用指定的比较器

IllegalArgumentException - （可选）如果发现比较器违反了 Comparator 合同

sort

public static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator <? super T> c)
            

根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。要排序的范围从索引 fromIndex 延伸到索引 toIndex ，不包括在内。 （如果 fromIndex==toIndex ，则要排序的范围为空。）范围内的所有元素必须是相互比较由指定的比较器（即，c.compare(e1, e2) 不得为范围内的任何元素 e1 和 e2 抛出 ClassCastException）。

这种类型保证是稳定的: 相等的元素不会因排序而重新排序。

实现注意事项：此实现是一种稳定的、自适应的、迭代的合并排序，当输入数组部分排序时需要的比较少于 n lg(n) 次，同时在输入数组随机排序时提供传统合并排序的性能。如果输入数组几乎已排序，则实现需要大约 n 次比较。临时存储要求从用于几乎排序的输入数组的小常量到用于随机排序的输入数组的 n/2 对象引用不等。

该实现在其输入数组中同样利用升序和降序，并且可以在同一输入数组的不同部分利用升序和降序。它非常适合合并两个或多个排序的数组：简单地连接数组并对结果数组进行排序。

该实现适配自 Tim Peters 的 Python 列表排序 ( TimSort)。它使用了 Peter McIlroy 的“乐观排序和信息理论复杂性”中的技术，在第四届年度 ACM-SIAM 离散算法研讨会论文集中，第 467-474 页，1993 年 1 月。

类型参数：

T - 要排序的对象的类

参数：

a - 要排序的数组

fromIndex - 要排序的第一个元素（包括）的索引

toIndex - 要排序的最后一个元素（不包括）的索引

c - 确定数组顺序的比较器。 null 值表示应使用元素的 自然排序。

抛出：

ClassCastException - 如果数组包含的元素不是相互比较使用指定的比较器。

IllegalArgumentException - 如果 fromIndex > toIndex 或（可选）如果发现比较器违反 Comparator 合同

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

parallelPrefix

public static <T> void parallelPrefix(T[] array, BinaryOperator <T> op)
            

使用提供的函数并行地累积给定数组的每个元素。例如，如果数组最初包含 [2, 1, 0, 3] 并且操作执行加法，则返回时数组包含 [2, 3, 3, 6] 。对于大型数组，并行前缀计算通常比顺序循环更有效。

类型参数：

T - 数组中对象的类

参数：

array - 通过此方法就地修改的数组

op - 一个无副作用的关联函数来执行累积

抛出：

NullPointerException - 如果指定的数组或函数为空

自从：

1.8

parallelPrefix

public static <T> void parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator <T> op)
            

对数组的给定子范围执行 parallelPrefix(Object[], BinaryOperator) 。

类型参数：

T - 数组中对象的类

参数：

array - 数组

fromIndex - 第一个元素的索引，包含在内

toIndex - 最后一个元素的索引，独占

op - 一个无副作用的关联函数来执行累积

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > array.length

NullPointerException - 如果指定的数组或函数为空

自从：

1.8

parallelPrefix

public static void parallelPrefix(long[] array, LongBinaryOperator  op)
            

使用提供的函数并行地累积给定数组的每个元素。例如，如果数组最初包含 [2, 1, 0, 3] 并且操作执行加法，则返回时数组包含 [2, 3, 3, 6] 。对于大型数组，并行前缀计算通常比顺序循环更有效。

参数：

array - 通过此方法就地修改的数组

op - 一个无副作用的关联函数来执行累积

抛出：

NullPointerException - 如果指定的数组或函数为空

自从：

1.8

parallelPrefix

public static void parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator  op)
            

对数组的给定子范围执行 parallelPrefix(long[], LongBinaryOperator) 。

参数：

array - 数组

fromIndex - 第一个元素的索引，包含在内

toIndex - 最后一个元素的索引，独占

op - 一个无副作用的关联函数来执行累积

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > array.length

NullPointerException - 如果指定的数组或函数为空

自从：

1.8

parallelPrefix

public static void parallelPrefix(double[] array, DoubleBinaryOperator  op)
            

使用提供的函数并行地累积给定数组的每个元素。例如，如果数组最初包含 [2.0, 1.0, 0.0, 3.0] 并且操作执行加法，则返回时数组包含 [2.0, 3.0, 3.0, 6.0] 。对于大型数组，并行前缀计算通常比顺序循环更有效。

因为浮点运算可能不是严格关联的，所以返回的结果可能与按顺序执行运算时获得的值不同。

参数：

array - 通过此方法就地修改的数组

op - 执行累积的无副作用函数

抛出：

NullPointerException - 如果指定的数组或函数为空

自从：

1.8

parallelPrefix

public static void parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator  op)
            

对数组的给定子范围执行 parallelPrefix(double[], DoubleBinaryOperator) 。

参数：

array - 数组

fromIndex - 第一个元素的索引，包含在内

toIndex - 最后一个元素的索引，独占

op - 一个无副作用的关联函数来执行累积

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > array.length

NullPointerException - 如果指定的数组或函数为空

自从：

1.8

parallelPrefix

public static void parallelPrefix(int[] array, IntBinaryOperator  op)
            

使用提供的函数并行地累积给定数组的每个元素。例如，如果数组最初包含 [2, 1, 0, 3] 并且操作执行加法，则返回时数组包含 [2, 3, 3, 6] 。对于大型数组，并行前缀计算通常比顺序循环更有效。

参数：

array - 通过此方法就地修改的数组

op - 一个无副作用的关联函数来执行累积

抛出：

NullPointerException - 如果指定的数组或函数为空

自从：

1.8

parallelPrefix

public static void parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator  op)
            

对数组的给定子范围执行 parallelPrefix(int[], IntBinaryOperator) 。

参数：

array - 数组

fromIndex - 第一个元素的索引，包含在内

toIndex - 最后一个元素的索引，独占

op - 一个无副作用的关联函数来执行累积

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > array.length

NullPointerException - 如果指定的数组或函数为空

自从：

1.8

binarySearch

public static int binarySearch(long[] a, long key)
            

使用二进制搜索算法在指定的 longs 数组中搜索指定的值。在进行此调用之前，必须对数组进行排序（如通过 sort(long[]) 方法）。如果未排序，则结果未定义。如果数组包含多个具有指定值的元素，则无法保证找到哪一个。

参数：

a - 要搜索的数组

key - 要搜索的值

返回：

搜索键的索引，如果它包含在数组中；否则，(-(insertion point) - 1)。这插入点被定义为将键插入数组的点：大于键的第一个元素的索引，或者 a.length 如果数组中的所有元素都小于指定的键。请注意，当且仅当找到密钥时，这保证返回值 >= 0。

binarySearch

public static int binarySearch(long[] a, int fromIndex, int toIndex, long key)
            

使用二进制搜索算法在指定的 long 数组范围内搜索指定值。在进行此调用之前，必须对范围进行排序（如通过 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)
            

使用二进制搜索算法在指定的整数数组中搜索指定的值。在进行此调用之前，必须对数组进行排序（如通过 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)
            

使用二进制搜索算法在指定的 shorts 数组中搜索指定的值。在进行此调用之前，必须对数组进行排序（如通过 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)
            

使用二进制搜索算法在指定数组中搜索指定对象。在进行此调用之前，必须根据其元素的 自然排序（如通过 sort(Object[]) 方法）对数组进行升序排序。如果未排序，则结果未定义。 （如果数组包含不可相互比较的元素（例如，字符串和整数），它不能根据其元素的自然顺序进行排序，因此结果未定义。）如果数组包含多个等于指定对象的元素，则无法保证找到哪一个。

参数：

a - 要搜索的数组

key - 要搜索的值

返回：

搜索键的索引，如果它包含在数组中；否则，(-(insertion point) - 1)。这插入点被定义为将键插入数组的点：大于键的第一个元素的索引，或者 a.length 如果数组中的所有元素都小于指定的键。请注意，当且仅当找到密钥时，这保证返回值 >= 0。

抛出：

ClassCastException - 如果搜索关键字与数组的元素不可比。

binarySearch

public static int binarySearch(Object [] a, int fromIndex, int toIndex, Object  key)
            

使用二进制搜索算法在指定数组的范围内搜索指定对象。在进行此调用之前，必须根据其元素的 自然排序（如通过 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 值表示应使用元素的 自然排序。

返回：

搜索键的索引，如果它包含在数组中；否则，(-(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 值表示应使用元素的 自然排序。

返回：

搜索关键字的索引，如果它包含在指定范围内的数组中；否则，(-(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 数组是，则返回 trueequal彼此。如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等，则认为两个数组相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。此外，如果两个数组引用都是 null ，则认为它们相等。

参数：

a - 要测试相等性的一个数组

a2 - 要测试是否相等的另一个数组

返回：

true 如果两个数组相等

equals

public static boolean equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)
            

如果在指定范围内的两个指定的 longs 数组是equal彼此。

如果每个范围所重写的元素数量相同，并且两个数组中指定范围内的所有对应元素对都相等，则认为两个数组相等。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。

参数：

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)
            

如果两个指定的整数数组是，则返回 trueequal彼此。如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等，则认为两个数组相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。此外，如果两个数组引用都是 null ，则认为它们相等。

参数：

a - 要测试相等性的一个数组

a2 - 要测试是否相等的另一个数组

返回：

true 如果两个数组相等

equals

public static boolean equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)
            

如果指定范围内的两个指定整数数组是equal彼此。

如果每个范围所重写的元素数量相同，并且两个数组中指定范围内的所有对应元素对都相等，则认为两个数组相等。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。

参数：

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)
            

如果两个指定的短裤数组是，则返回 trueequal彼此。如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等，则认为两个数组相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。此外，如果两个数组引用都是 null ，则认为它们相等。

参数：

a - 要测试相等性的一个数组

a2 - 要测试是否相等的另一个数组

返回：

true 如果两个数组相等

equals

public static boolean equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)
            

如果指定范围内的两个指定短裤数组是equal彼此。

如果每个范围所重写的元素数量相同，并且两个数组中指定范围内的所有对应元素对都相等，则认为两个数组相等。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。

参数：

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)
            

如果两个指定的字符数组是，则返回 trueequal彼此。如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等，则认为两个数组相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。此外，如果两个数组引用都是 null ，则认为它们相等。

参数：

a - 要测试相等性的一个数组

a2 - 要测试是否相等的另一个数组

返回：

true 如果两个数组相等

equals

public static boolean equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)
            

如果指定范围内的两个指定字符数组是equal彼此。

如果每个范围所重写的元素数量相同，并且两个数组中指定范围内的所有对应元素对都相等，则认为两个数组相等。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。

参数：

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)
            

如果两个指定的字节数组是，则返回 trueequal彼此。如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等，则认为两个数组相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。此外，如果两个数组引用都是 null ，则认为它们相等。

参数：

a - 要测试相等性的一个数组

a2 - 要测试是否相等的另一个数组

返回：

true 如果两个数组相等

equals

public static boolean equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)
            

如果指定范围内的两个指定字节数组是equal彼此。

如果每个范围所重写的元素数量相同，并且两个数组中指定范围内的所有对应元素对都相等，则认为两个数组相等。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。

参数：

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)
            

如果两个指定的布尔数组是，则返回 trueequal彼此。如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等，则认为两个数组相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。此外，如果两个数组引用都是 null ，则认为它们相等。

参数：

a - 要测试相等性的一个数组

a2 - 要测试是否相等的另一个数组

返回：

true 如果两个数组相等

equals

public static boolean equals(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)
            

如果指定范围内的两个指定的布尔数组是equal彼此。

如果每个范围所重写的元素数量相同，并且两个数组中指定范围内的所有对应元素对都相等，则认为两个数组相等。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。

参数：

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)
            

如果两个指定的双精度数组是，则返回 trueequal彼此。如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等，则认为两个数组相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。此外，如果两个数组引用都是 null ，则认为它们相等。两个双打 d1 和 d2 被认为相等，如果：

  Double.valueOf(d1).equals(Double.valueOf(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)
            

如果指定范围内的两个指定双精度数组是equal彼此。

如果每个范围所重写的元素数量相同，并且两个数组中指定范围内的所有对应元素对都相等，则认为两个数组相等。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。

两个双打 d1 和 d2 被认为是相等的，如果：

  Double.valueOf(d1).equals(Double.valueOf(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)
            

如果两个指定的浮点数数组是，则返回 trueequal彼此。如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等，则认为两个数组相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。此外，如果两个数组引用都是 null ，则认为它们相等。两个浮点数 f1 和 f2 被视为相等，如果：

  Float.valueOf(f1).equals(Float.valueOf(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)
            

如果指定范围内的两个指定浮点数数组是equal彼此。

如果每个范围所重写的元素数量相同，并且两个数组中指定范围内的所有对应元素对都相等，则认为两个数组相等。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。

两个浮点数 f1 和 f2 被认为是相等的，如果：

  Float.valueOf(f1).equals(Float.valueOf(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)
            

如果两个指定的对象数组是返回 trueequal彼此。如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等，则认为这两个数组相等。考虑了两个对象 e1 和 e2equal如果Objects.equals(e1, e2)。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。此外，如果两个数组引用都是 null ，则认为它们相等。

参数：

a - 要测试相等性的一个数组

a2 - 要测试是否相等的另一个数组

返回：

true 如果两个数组相等

equals

public static boolean equals(Object [] a, int aFromIndex, int aToIndex, Object [] b, int bFromIndex, int bToIndex)
            

如果指定范围内的两个指定对象数组是equal彼此。

如果每个范围所重写的元素数量相同，并且两个数组中指定范围内的所有对应元素对都相等，则认为两个数组相等。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。

考虑了两个对象 e1 和 e2equal如果Objects.equals(e1, e2)。

参数：

a - 第一个要进行相等性测试的数组

aFromIndex - 要测试的第一个数组中第一个元素的索引（包括）

aToIndex - 要测试的第一个数组中最后一个元素的索引（不包括）

b - 要测试相等性的第二个数组

bFromIndex - 要测试的第二个数组中第一个元素的索引（含）

bToIndex - 要测试的第二个数组中最后一个元素的索引（不包括）

返回：

true 如果指定范围内的两个数组相等

抛出：

IllegalArgumentException - 如果 aFromIndex > aToIndex 或如果 bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - 如果 aFromIndex < 0 or aToIndex > a.length 或如果 bFromIndex < 0 or bToIndex > b.length

NullPointerException - 如果任一数组是 null

自从：

9

equals

public static <T> boolean equals(T[] a, T[] a2, Comparator <? super T> cmp)
            

如果两个指定的对象数组是返回 trueequal彼此。

如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等，则认为两个数组相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。此外，如果两个数组引用都是 null ，则认为它们相等。

考虑了两个对象 e1 和 e2equal如果，给定指定的比较器，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)
            

如果指定范围内的两个指定对象数组是equal彼此。

如果每个范围所重写的元素数量相同，并且两个数组中指定范围内的所有对应元素对都相等，则认为两个数组相等。换句话说，如果两个数组在指定范围内包含相同顺序的相同元素，则它们是相等的。

考虑了两个对象 e1 和 e2equal如果，给定指定的比较器，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 值分配给指定的 long 数组的每个元素。

参数：

a - 要填充的数组

val - 要存储在数组所有元素中的值

fill

public static void fill(long[] a, int fromIndex, int toIndex, long val)
            

将指定的 long 值分配给指定 long 数组的指定范围内的每个元素。要填充的范围从索引 fromIndex 开始，包括在内，到索引 toIndex 不包括在内。 （如果 fromIndex==toIndex ，则要填充的范围为空。）

参数：

a - 要填充的数组

fromIndex - 要填充指定值的第一个元素（含）的索引

toIndex - 要填充指定值的最后一个元素（不包括）的索引

val - 要存储在数组所有元素中的值

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

fill

public static void fill(int[] a, int val)
            

将指定的 int 值分配给指定的 int 数组的每个元素。

参数：

a - 要填充的数组

val - 要存储在数组所有元素中的值

fill

public static void fill(int[] a, int fromIndex, int toIndex, int val)
            

将指定的 int 值分配给指定 int 数组的指定范围内的每个元素。要填充的范围从索引 fromIndex 开始，包括在内，到索引 toIndex 不包括在内。 （如果 fromIndex==toIndex ，则要填充的范围为空。）

参数：

a - 要填充的数组

fromIndex - 要填充指定值的第一个元素（含）的索引

toIndex - 要填充指定值的最后一个元素（不包括）的索引

val - 要存储在数组所有元素中的值

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

fill

public static void fill(short[] a, short val)
            

将指定的 short 值分配给指定的 short 数组的每个元素。

参数：

a - 要填充的数组

val - 要存储在数组所有元素中的值

fill

public static void fill(short[] a, int fromIndex, int toIndex, short val)
            

将指定的短整型值分配给指定短整型数组的指定范围内的每个元素。要填充的范围从索引 fromIndex 开始，包括在内，到索引 toIndex 不包括在内。 （如果 fromIndex==toIndex ，则要填充的范围为空。）

参数：

a - 要填充的数组

fromIndex - 要填充指定值的第一个元素（含）的索引

toIndex - 要填充指定值的最后一个元素（不包括）的索引

val - 要存储在数组所有元素中的值

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

fill

public static void fill(char[] a, char val)
            

将指定的 char 值分配给指定的 char 数组的每个元素。

参数：

a - 要填充的数组

val - 要存储在数组所有元素中的值

fill

public static void fill(char[] a, int fromIndex, int toIndex, char val)
            

将指定的 char 值分配给指定字符数组的指定范围内的每个元素。要填充的范围从索引 fromIndex 开始，包括在内，到索引 toIndex 不包括在内。 （如果 fromIndex==toIndex ，则要填充的范围为空。）

参数：

a - 要填充的数组

fromIndex - 要填充指定值的第一个元素（含）的索引

toIndex - 要填充指定值的最后一个元素（不包括）的索引

val - 要存储在数组所有元素中的值

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

fill

public static void fill(byte[] a, byte val)
            

将指定字节值分配给指定字节数组的每个元素。

参数：

a - 要填充的数组

val - 要存储在数组所有元素中的值

fill

public static void fill(byte[] a, int fromIndex, int toIndex, byte val)
            

将指定字节值分配给指定字节数组的指定范围内的每个元素。要填充的范围从索引 fromIndex 开始，包括在内，到索引 toIndex 不包括在内。 （如果 fromIndex==toIndex ，则要填充的范围为空。）

参数：

a - 要填充的数组

fromIndex - 要填充指定值的第一个元素（含）的索引

toIndex - 要填充指定值的最后一个元素（不包括）的索引

val - 要存储在数组所有元素中的值

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

fill

public static void fill(boolean[] a, boolean val)
            

将指定的boolean分配给指定的布尔数组的每个元素。

参数：

a - 要填充的数组

val - 要存储在数组所有元素中的值

fill

public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)
            

将指定的boolean分配给指定布尔数组的指定范围内的每个元素。要填充的范围从索引 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)
            

将指定的双精度值分配给指定双精度数组的每个元素。

参数：

a - 要填充的数组

val - 要存储在数组所有元素中的值

fill

public static void fill(double[] a, int fromIndex, int toIndex, double val)
            

将指定的双精度值分配给指定双精度数组的指定范围内的每个元素。要填充的范围从索引 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)
            

将指定的浮点值分配给指定的浮点数组的每个元素。

参数：

a - 要填充的数组

val - 要存储在数组所有元素中的值

fill

public static void fill(float[] a, int fromIndex, int toIndex, float val)
            

将指定的浮点值分配给指定浮点数数组的指定范围内的每个元素。要填充的范围从索引 fromIndex 延伸到索引 toIndex ，包括在内。 （如果 fromIndex==toIndex ，则要填充的范围为空。）

参数：

a - 要填充的数组

fromIndex - 要填充指定值的第一个元素（含）的索引

toIndex - 要填充指定值的最后一个元素（不包括）的索引

val - 要存储在数组所有元素中的值

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

fill

public static void fill(Object [] a, Object  val)
            

将指定的对象引用分配给指定对象数组的每个元素。

参数：

a - 要填充的数组

val - 要存储在数组所有元素中的值

抛出：

ArrayStoreException - 如果指定值不是可以存储在指定数组中的运行时类型

fill

public static void fill(Object [] a, int fromIndex, int toIndex, Object  val)
            

将指定的对象引用分配给指定对象数组的指定范围内的每个元素。要填充的范围从索引 fromIndex 延伸到索引 toIndex ，包括在内。 （如果 fromIndex==toIndex ，则要填充的范围为空。）

参数：

a - 要填充的数组

fromIndex - 要填充指定值的第一个元素（含）的索引

toIndex - 要填充指定值的最后一个元素（不包括）的索引

val - 要存储在数组所有元素中的值

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

ArrayStoreException - 如果指定值不是可以存储在指定数组中的运行时类型

copyOf

public static <T> T[] copyOf(T[] original, int newLength)
            

复制指定的数组，用空值截断或填充（如有必要），以便副本具有指定的长度。对于在原始数组和副本中均有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但在原始文件中无效的任何索引，副本将包含 null 。当且仅当指定的长度大于原始数组的长度时，此类索引才会存在。结果数组与原始数组属于完全相同的类。

类型参数：

T - 数组中对象的类

参数：

original - 要复制的数组

newLength - 要返回的副本的长度

返回：

原始数组的副本，截断或用空值填充以获得指定长度

抛出：

NegativeArraySizeException - 如果 newLength 为负

NullPointerException - 如果 original 为空

自从：

1.6

copyOf

public static <T, U> T[] copyOf(U[] original, int newLength, Class <? extends T[]> newType)
            

复制指定的数组，用空值截断或填充（如有必要），以便副本具有指定的长度。对于在原始数组和副本中均有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但在原始文件中无效的任何索引，副本将包含 null 。当且仅当指定的长度大于原始数组的长度时，此类索引才会存在。结果数组属于 newType 类。

类型参数：

T - 返回数组中对象的类

U - 原始数组中对象的类

参数：

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)
            

复制指定的数组，用空字符截断或填充（如有必要），使副本具有指定的长度。对于在原始数组和副本中均有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但在原始文件中无效的任何索引，副本将包含 '\u0000' 。当且仅当指定的长度大于原始数组的长度时，此类索引才会存在。

参数：

original - 要复制的数组

newLength - 要返回的副本的长度

返回：

原始数组的副本，截断或用空字符填充以获得指定长度

抛出：

NegativeArraySizeException - 如果 newLength 为负

NullPointerException - 如果 original 为空

自从：

1.6

copyOf

public static float[] copyOf(float[] original, int newLength)
            

复制指定的数组，用零截断或填充（如有必要），使副本具有指定的长度。对于在原始数组和副本中均有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但在原始文件中无效的任何索引，副本将包含 0f 。当且仅当指定的长度大于原始数组的长度时，此类索引才会存在。

参数：

original - 要复制的数组

newLength - 要返回的副本的长度

返回：

原始数组的副本，截断或用零填充以获得指定长度

抛出：

NegativeArraySizeException - 如果 newLength 为负

NullPointerException - 如果 original 为空

自从：

1.6

copyOf

public static double[] copyOf(double[] original, int newLength)
            

复制指定的数组，用零截断或填充（如有必要），使副本具有指定的长度。对于在原始数组和副本中均有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但在原始文件中无效的任何索引，副本将包含 0d 。当且仅当指定的长度大于原始数组的长度时，此类索引才会存在。

参数：

original - 要复制的数组

newLength - 要返回的副本的长度

返回：

原始数组的副本，截断或用零填充以获得指定长度

抛出：

NegativeArraySizeException - 如果 newLength 为负

NullPointerException - 如果 original 为空

自从：

1.6

copyOf

public static boolean[] copyOf(boolean[] original, int newLength)
            

复制指定的数组，用 false 截断或填充（如有必要），以便副本具有指定的长度。对于在原始数组和副本中均有效的所有索引，这两个数组将包含相同的值。对于在副本中有效但在原始文件中无效的任何索引，副本将包含 false 。当且仅当指定的长度大于原始数组的长度时，此类索引才会存在。

参数：

original - 要复制的数组

newLength - 要返回的副本的长度

返回：

原始数组的副本，截断或用假元素填充以获得指定长度

抛出：

NegativeArraySizeException - 如果 newLength 为负

NullPointerException - 如果 original 为空

自从：

1.6

copyOfRange

public static <T> T[] copyOfRange(T[] original, int from, int to)
            

将指定数组的指定范围复制到新数组中。范围的初始索引 (from) 必须介于零和 original.length 之间，包括在内。 original[from] 处的值被放入副本的初始元素（除非 from == original.length 或 from == to ）。来自原始数组中后续元素的值被放入副本中的后续元素中。范围的最终索引 (to) 必须大于或等于 from，可能大于 original.length，在这种情况下，null 将放置在索引大于或等于 original.length - from 的副本的所有元素中。返回数组的长度将为 to - from 。

结果数组与原始数组属于完全相同的类。

类型参数：

T - 数组中对象的类

参数：

original - 要从中复制范围的数组

from - 要复制的范围的初始索引，包括在内

to - 要复制的范围的最终索引，独占。 （该索引可能位于数组之外。）

返回：

包含原始数组指定范围的新数组，截断或用空值填充以获得所需的长度

抛出：

ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length

IllegalArgumentException - 如果 from > to

NullPointerException - 如果 original 为空

自从：

1.6

copyOfRange

public static <T, U> T[] copyOfRange(U[] original, int from, int to, Class <? extends T[]> newType)
            

将指定数组的指定范围复制到新数组中。范围的初始索引 (from) 必须介于零和 original.length 之间，包括在内。 original[from] 处的值被放入副本的初始元素（除非 from == original.length 或 from == to ）。来自原始数组中后续元素的值被放入副本中的后续元素中。范围的最终索引 (to) 必须大于或等于 from，可能大于 original.length，在这种情况下，null 将放置在索引大于或等于 original.length - from 的副本的所有元素中。返回数组的长度将为 to - from 。结果数组属于 newType 类。

类型参数：

T - 返回数组中对象的类

U - 原始数组中对象的类

参数：

original - 要从中复制范围的数组

from - 要复制的范围的初始索引，包括在内

to - 要复制的范围的最终索引，独占。 （该索引可能位于数组之外。）

newType - 要返回的副本的类

返回：

包含原始数组指定范围的新数组，截断或用空值填充以获得所需的长度

抛出：

ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length

IllegalArgumentException - 如果 from > to

NullPointerException - 如果 original 为空

ArrayStoreException - 如果从 original 复制的元素不是可以存储在类 newType 的数组中的运行时类型。

自从：

1.6

copyOfRange

public static byte[] copyOfRange(byte[] original, int from, int to)
            

将指定数组的指定范围复制到新数组中。范围的初始索引 (from) 必须介于零和 original.length 之间，包括在内。 original[from] 处的值被放入副本的初始元素（除非 from == original.length 或 from == to ）。来自原始数组中后续元素的值被放入副本中的后续元素中。范围的最终索引 (to) 必须大于或等于 from，可能大于 original.length，在这种情况下，(byte)0 将放置在索引大于或等于 original.length - from 的副本的所有元素中。返回数组的长度将为 to - from 。

参数：

original - 要从中复制范围的数组

from - 要复制的范围的初始索引，包括在内

to - 要复制的范围的最终索引，独占。 （该索引可能位于数组之外。）

返回：

包含原始数组中指定范围的新数组，截断或用零填充以获得所需的长度

抛出：

ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length

IllegalArgumentException - 如果 from > to

NullPointerException - 如果 original 为空

自从：

1.6

copyOfRange

public static short[] copyOfRange(short[] original, int from, int to)
            

将指定数组的指定范围复制到新数组中。范围的初始索引 (from) 必须介于零和 original.length 之间，包括在内。 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) 必须介于零和 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) 必须介于零和 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) 必须介于零和 original.length 之间，包括在内。 original[from] 处的值被放入副本的初始元素（除非 from == original.length 或 from == to ）。来自原始数组中后续元素的值被放入副本中的后续元素中。范围的最终索引 (to) 必须大于或等于 from，可能大于 original.length，在这种情况下，'\u0000' 将放置在索引大于或等于 original.length - from 的副本的所有元素中。返回数组的长度将为 to - from 。

参数：

original - 要从中复制范围的数组

from - 要复制的范围的初始索引，包括在内

to - 要复制的范围的最终索引，独占。 （该索引可能位于数组之外。）

返回：

包含原始数组指定范围的新数组，截断或用空字符填充以获得所需的长度

抛出：

ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length

IllegalArgumentException - 如果 from > to

NullPointerException - 如果 original 为空

自从：

1.6

copyOfRange

public static float[] copyOfRange(float[] original, int from, int to)
            

将指定数组的指定范围复制到新数组中。范围的初始索引 (from) 必须介于零和 original.length 之间，包括在内。 original[from] 处的值被放入副本的初始元素（除非 from == original.length 或 from == to ）。来自原始数组中后续元素的值被放入副本中的后续元素中。范围的最终索引 (to) 必须大于或等于 from，可能大于 original.length，在这种情况下，0f 将放置在索引大于或等于 original.length - from 的副本的所有元素中。返回数组的长度将为 to - from 。

参数：

original - 要从中复制范围的数组

from - 要复制的范围的初始索引，包括在内

to - 要复制的范围的最终索引，独占。 （该索引可能位于数组之外。）

返回：

包含原始数组中指定范围的新数组，截断或用零填充以获得所需的长度

抛出：

ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length

IllegalArgumentException - 如果 from > to

NullPointerException - 如果 original 为空

自从：

1.6

copyOfRange

public static double[] copyOfRange(double[] original, int from, int to)
            

将指定数组的指定范围复制到新数组中。范围的初始索引 (from) 必须介于零和 original.length 之间，包括在内。 original[from] 处的值被放入副本的初始元素（除非 from == original.length 或 from == to ）。来自原始数组中后续元素的值被放入副本中的后续元素中。范围的最终索引 (to) 必须大于或等于 from，可能大于 original.length，在这种情况下，0d 将放置在索引大于或等于 original.length - from 的副本的所有元素中。返回数组的长度将为 to - from 。

参数：

original - 要从中复制范围的数组

from - 要复制的范围的初始索引，包括在内

to - 要复制的范围的最终索引，独占。 （该索引可能位于数组之外。）

返回：

包含原始数组中指定范围的新数组，截断或用零填充以获得所需的长度

抛出：

ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length

IllegalArgumentException - 如果 from > to

NullPointerException - 如果 original 为空

自从：

1.6

copyOfRange

public static boolean[] copyOfRange(boolean[] original, int from, int to)
            

将指定数组的指定范围复制到新数组中。范围的初始索引 (from) 必须介于零和 original.length 之间，包括在内。 original[from] 处的值被放入副本的初始元素（除非 from == original.length 或 from == to ）。来自原始数组中后续元素的值被放入副本中的后续元素中。范围的最终索引 (to) 必须大于或等于 from，可能大于 original.length，在这种情况下，false 将放置在索引大于或等于 original.length - from 的副本的所有元素中。返回数组的长度将为 to - from 。

参数：

original - 要从中复制范围的数组

from - 要复制的范围的初始索引，包括在内

to - 要复制的范围的最终索引，独占。 （该索引可能位于数组之外。）

返回：

包含原始数组中指定范围的新数组，截断或填充假元素以获得所需的长度

抛出：

ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length

IllegalArgumentException - 如果 from > to

NullPointerException - 如果 original 为空

自从：

1.6

asList

@SafeVarargs public static <T> List <T> asList(T... a)
            

返回由指定数组支持的固定大小列表。对数组所做的更改将在返回的列表中可见，而对列表所做的更改将在数组中可见。返回的列表是 Serializable 并实现了 RandomAccess 。

返回的列表实现了可选的 Collection 方法，但那些会改变返回列表大小的方法除外。这些方法保持列表不变并抛出 UnsupportedOperationException 。

API 注意：

此方法与 Collection.toArray() 结合，充当基于数组和基于集合的 API 之间的桥梁。

此方法提供了一种包装现有数组的方法：

   Integer[] numbers = ...
   ...
   List<Integer> values = Arrays.asList(numbers);
  

此方法还提供了一种方便的方法来创建初始化为包含多个元素的固定大小列表：

   List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
  

The list returned by this method is modifiable. 要创建不可修改的列表，请使用 Collections.unmodifiableList 或 不可修改的列表。

类型参数：

T - 数组中对象的类

参数：

a - 支持列表的数组

返回：

指定数组的列表视图

抛出：

NullPointerException - 如果指定的数组是 null

hashCode

public static int hashCode(long[] a)
            

根据指定数组的内容返回哈希码。对于任何两个 long 数组 a 和 b 这样 Arrays.equals(a, b) ，它也是 Arrays.hashCode(a) == Arrays.hashCode(b) 的情况。

此方法返回的值与通过在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 元素的 Long 实例序列。如果 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) 的情况。

此方法返回的值与通过在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 元素的 Integer 实例序列。如果 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) 的情况。

此方法返回的值与通过在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 元素的 Short 实例序列。如果 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) 的情况。

此方法返回的值与通过在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 元素的 Character 实例序列。如果 a 是 null ，则此方法返回 0。

参数：

a - 要计算其哈希值的数组

返回：

a 的基于内容的哈希码

自从：

1.5

hashCode

public static int hashCode(byte[] a)
            

根据指定数组的内容返回哈希码。对于任何两个 byte 数组 a 和 b 这样 Arrays.equals(a, b) ，它也是 Arrays.hashCode(a) == Arrays.hashCode(b) 的情况。

此方法返回的值与通过在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 元素的 Byte 实例序列。如果 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) 的情况。

此方法返回的值与通过在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 元素的 Boolean 实例序列。如果 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) 的情况。

此方法返回的值与通过在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 元素的 Float 实例序列。如果 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) 的情况。

此方法返回的值与通过在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 元素的 Double 实例序列。如果 a 是 null ，则此方法返回 0。

参数：

a - 要计算其哈希值的数组

返回：

a 的基于内容的哈希码

自从：

1.5

hashCode

public static int hashCode(Object [] a)
            

根据指定数组的内容返回哈希码。如果该数组包含其他数组作为元素，则哈希码基于它们的标识而不是它们的内容。因此，可以直接或通过一个或多个级别的数组间接地在包含自身作为元素的数组上调用此方法。

对于任何两个数组 a 和 b 这样 Arrays.equals(a, b) ，它也是 Arrays.hashCode(a) == Arrays.hashCode(b) 的情况。

此方法返回的值等于 Arrays.asList(a).hashCode() 返回的值，除非 a 是 null，在这种情况下返回 0。

参数：

a - 要计算其基于内容的哈希码的数组

返回：

a 的基于内容的哈希码

自从：

1.5

参见：

• deepHashCode(Object[])

deepHashCode

public static int deepHashCode(Object [] a)
            

返回基于指定数组的“深层内容”的哈希码。如果该数组包含其他数组作为元素，则哈希码基于它们的内容，依此类推，无穷无尽。因此，直接或通过一个或多个级别的数组间接地在包含自身作为元素的数组上调用此方法是不可接受的。这种调用的行为是未定义的。

对于任何两个数组 a 和 b 这样 Arrays.deepEquals(a, b) ，它也是 Arrays.deepHashCode(a) == Arrays.deepHashCode(b) 的情况。

此方法返回值的计算类似于 List.hashCode() 在包含与 a 相同的元素且顺序相同的列表中返回的值的计算，但有一个区别：如果 a 的元素 e 本身是一个数组，则其哈希code 不是通过调用 e.hashCode() 计算的，而是通过调用 Arrays.hashCode(e) 的适当重载（如果 e 是基本类型的数组），或者通过调用 Arrays.deepHashCode(e) 递归（如果 e 是引用类型的数组）。如果 a 是 null ，则此方法返回 0。

参数：

a - 要计算其基于深度内容的哈希码的数组

返回：

a 的基于深度内容的哈希码

自从：

1.5

参见：

• hashCode(Object[])

deepEquals

public static boolean deepEquals(Object [] a1, Object [] a2)
            

如果两个指定的数组是，则返回 true深深地平等彼此。与 equals(Object[],Object[]) 方法不同，此方法适用于任意深度的嵌套数组。

如果两个数组引用都是 null ，或者如果它们引用包含相同数量元素的数组并且两个数组中所有对应的元素对都深度相等，则认为两个数组引用深度相等。

如果满足以下任何条件，则两个可能的 null 元素 e1 和 e2 深度相等：

• e1 和 e2 都是对象引用类型的数组，而 Arrays.deepEquals(e1, e2) would return true
• e1 和 e2 是相同原始类型的数组，Arrays.equals(e1, e2) 的适当重载将返回 true。
• e1 == e2
• e1.equals(e2) 将返回 true。

请注意，此定义允许任何深度的 null 个元素。

如果任一指定数组直接或通过一个或多个级别的数组间接将自身包含为元素，则此方法的行为未定义。

参数：

a1 - 要测试是否相等的一个数组

a2 - 要测试是否相等的另一个数组

返回：

true 如果两个数组相等

自从：

1.5

参见：

• equals(Object[],Object[])
• Objects.deepEquals(Object, Object)

toString

public static String  toString(long[] a)
            

返回指定数组内容的字符串表示形式。字符串表示形式由数组元素列表组成，括在方括号 ("[]") 中。相邻元素由字符 ", " 分隔（一个逗号后跟一个空格）。元素按 String.valueOf(long) 转换为字符串。如果 a 是 null，则返回 "null"。

参数：

a - 要返回其字符串表示形式的数组

返回：

a 的字符串表示形式

自从：

1.5

toString

public static String  toString(int[] a)
            

返回指定数组内容的字符串表示形式。字符串表示形式由数组元素列表组成，括在方括号 ("[]") 中。相邻元素由字符 ", " 分隔（一个逗号后跟一个空格）。元素按 String.valueOf(int) 转换为字符串。如果 a 是 null，则返回 "null"。

参数：

a - 要返回其字符串表示形式的数组

返回：

a 的字符串表示形式

自从：

1.5

toString

public static String  toString(short[] a)
            

返回指定数组内容的字符串表示形式。字符串表示形式由数组元素列表组成，括在方括号 ("[]") 中。相邻元素由字符 ", " 分隔（一个逗号后跟一个空格）。元素按 String.valueOf(short) 转换为字符串。如果 a 是 null，则返回 "null"。

参数：

a - 要返回其字符串表示形式的数组

返回：

a 的字符串表示形式

自从：

1.5

toString

public static String  toString(char[] a)
            

返回指定数组内容的字符串表示形式。字符串表示形式由数组元素列表组成，括在方括号 ("[]") 中。相邻元素由字符 ", " 分隔（一个逗号后跟一个空格）。元素按 String.valueOf(char) 转换为字符串。如果 a 是 null，则返回 "null"。

参数：

a - 要返回其字符串表示形式的数组

返回：

a 的字符串表示形式

自从：

1.5

toString

public static String  toString(byte[] a)
            

返回指定数组内容的字符串表示形式。字符串表示形式由数组元素列表组成，括在方括号 ("[]") 中。相邻元素由字符 ", " 分隔（一个逗号后跟一个空格）。元素按 String.valueOf(byte) 转换为字符串。如果 a 是 null，则返回 "null"。

参数：

a - 要返回其字符串表示形式的数组

返回：

a 的字符串表示形式

自从：

1.5

toString

public static String  toString(boolean[] a)
            

返回指定数组内容的字符串表示形式。字符串表示形式由数组元素列表组成，括在方括号 ("[]") 中。相邻元素由字符 ", " 分隔（一个逗号后跟一个空格）。元素按 String.valueOf(boolean) 转换为字符串。如果 a 是 null，则返回 "null"。

参数：

a - 要返回其字符串表示形式的数组

返回：

a 的字符串表示形式

自从：

1.5

toString

public static String  toString(float[] a)
            

返回指定数组内容的字符串表示形式。字符串表示形式由数组元素列表组成，括在方括号 ("[]") 中。相邻元素由字符 ", " 分隔（一个逗号后跟一个空格）。元素按 String.valueOf(float) 转换为字符串。如果 a 是 null，则返回 "null"。

参数：

a - 要返回其字符串表示形式的数组

返回：

a 的字符串表示形式

自从：

1.5

toString

public static String  toString(double[] a)
            

返回指定数组内容的字符串表示形式。字符串表示形式由数组元素列表组成，括在方括号 ("[]") 中。相邻元素由字符 ", " 分隔（一个逗号后跟一个空格）。元素按 String.valueOf(double) 转换为字符串。如果 a 是 null，则返回 "null"。

参数：

a - 要返回其字符串表示形式的数组

返回：

a 的字符串表示形式

自从：

1.5

toString

public static String  toString(Object [] a)
            

返回指定数组内容的字符串表示形式。如果数组包含其他数组作为元素，则通过继承自 Object 的 Object.toString() 方法将它们转换为字符串，该方法描述了它们身份而不是他们的内容。

此方法返回的值等于 Arrays.asList(a).toString() 返回的值，除非 a 是 null，在这种情况下返回 "null"。

参数：

a - 要返回其字符串表示形式的数组

返回：

a 的字符串表示形式

自从：

1.5

参见：

• deepToString(Object[])

deepToString

public static String  deepToString(Object [] a)
            

返回指定数组的“深层内容”的字符串表示形式。如果该数组包含其他数组作为元素，则字符串表示形式包含它们的内容等。此方法专为将多维数组转换为字符串而设计。

字符串表示形式由数组元素列表组成，括在方括号 ("[]") 中。相邻元素由字符 ", " 分隔（一个逗号后跟一个空格）。元素按 String.valueOf(Object) 转换为字符串，除非它们本身是数组。

如果元素 e 是原始类型的数组，则通过调用 Arrays.toString(e) 的适当重载将其转换为字符串。如果元素 e 是引用类型的数组，则通过递归调用此方法将其转换为字符串。

为避免无限递归，如果指定数组包含自身作为元素，或包含通过一级或多级数组对自身的间接引用，则自引用将转换为字符串 "[...]" 。例如，仅包含对自身的引用的数组将呈现为 "[[...]]" 。

如果指定的数组是 null，则此方法返回 "null"。

参数：

a - 要返回其字符串表示形式的数组

返回：

a 的字符串表示形式

自从：

1.5

参见：

• toString(Object[])

setAll

public static <T> void setAll(T[] array, IntFunction <? extends T> generator)
            

设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，它会被传递给调用者并且数组处于不确定状态。

API 注意：

设置数组的子范围，使用生成器函数计算每个元素，可以这样写：

 IntStream.range(startInclusive, endExclusive)
     .forEach(i -> array[i] = generator.apply(i));
  

类型参数：

T - 数组元素的类型

参数：

array - 要初始化的数组

generator - 接受索引并为该位置生成所需值的函数

抛出：

NullPointerException - 如果生成器为空

自从：

1.8

parallelSetAll

public static <T> void parallelSetAll(T[] array, IntFunction <? extends T> generator)
            

并行设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，则会从 parallelSetAll 抛出未经检查的异常，并且数组将处于不确定状态。

API 注意：

设置一个数组的子范围，并行地，使用一个生成器函数来计算每个元素，可以这样写：

 IntStream.range(startInclusive, endExclusive)
     .parallel()
     .forEach(i -> array[i] = generator.apply(i));
  

类型参数：

T - 数组元素的类型

参数：

array - 要初始化的数组

generator - 接受索引并为该位置生成所需值的函数

抛出：

NullPointerException - 如果生成器为空

自从：

1.8

setAll

public static void setAll(int[] array, IntUnaryOperator  generator)
            

设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，它会被传递给调用者并且数组处于不确定状态。

API 注意：

设置数组的子范围，使用生成器函数计算每个元素，可以写成如下：

 IntStream.range(startInclusive, endExclusive)
     .forEach(i -> array[i] = generator.applyAsInt(i));
  

参数：

array - 要初始化的数组

generator - 接受索引并为该位置生成所需值的函数

抛出：

NullPointerException - 如果生成器为空

自从：

1.8

parallelSetAll

public static void parallelSetAll(int[] array, IntUnaryOperator  generator)
            

并行设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，则会从 parallelSetAll 抛出未经检查的异常，并且数组将处于不确定状态。

API 注意：

设置一个数组的子范围，并行地，使用一个生成器函数来计算每个元素，可以写成如下：

 IntStream.range(startInclusive, endExclusive)
     .parallel()
     .forEach(i -> array[i] = generator.applyAsInt(i));
  

参数：

array - 要初始化的数组

generator - 接受索引并为该位置生成所需值的函数

抛出：

NullPointerException - 如果生成器为空

自从：

1.8

setAll

public static void setAll(long[] array, IntToLongFunction  generator)
            

设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，它会被传递给调用者并且数组处于不确定状态。

API 注意：

设置数组的子范围，使用生成器函数计算每个元素，可以这样写：

 IntStream.range(startInclusive, endExclusive)
     .forEach(i -> array[i] = generator.applyAsLong(i));
  

参数：

array - 要初始化的数组

generator - 接受索引并为该位置生成所需值的函数

抛出：

NullPointerException - 如果生成器为空

自从：

1.8

parallelSetAll

public static void parallelSetAll(long[] array, IntToLongFunction  generator)
            

并行设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，则会从 parallelSetAll 抛出未经检查的异常，并且数组将处于不确定状态。

API 注意：

设置一个数组的子范围，并行地，使用一个生成器函数来计算每个元素，可以这样写：

 IntStream.range(startInclusive, endExclusive)
     .parallel()
     .forEach(i -> array[i] = generator.applyAsLong(i));
  

参数：

array - 要初始化的数组

generator - 接受索引并为该位置生成所需值的函数

抛出：

NullPointerException - 如果生成器为空

自从：

1.8

setAll

public static void setAll(double[] array, IntToDoubleFunction  generator)
            

设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，它会被传递给调用者并且数组处于不确定状态。

API 注意：

设置数组的子范围，使用生成器函数计算每个元素，可以这样写：

 IntStream.range(startInclusive, endExclusive)
     .forEach(i -> array[i] = generator.applyAsDouble(i));
  

参数：

array - 要初始化的数组

generator - 接受索引并为该位置生成所需值的函数

抛出：

NullPointerException - 如果生成器为空

自从：

1.8

parallelSetAll

public static void parallelSetAll(double[] array, IntToDoubleFunction  generator)
            

并行设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，则会从 parallelSetAll 抛出未经检查的异常，并且数组将处于不确定状态。

API 注意：

设置一个数组的子范围，并行地，使用一个生成器函数来计算每个元素，可以这样写：

 IntStream.range(startInclusive, endExclusive)
     .parallel()
     .forEach(i -> array[i] = generator.applyAsDouble(i));
  

参数：

array - 要初始化的数组

generator - 接受索引并为该位置生成所需值的函数

抛出：

NullPointerException - 如果生成器为空

自从：

1.8

spliterator

public static <T> Spliterator <T> spliterator(T[] array)
            

返回覆盖所有指定数组的 Spliterator 。

拆分器报告 Spliterator.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.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.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.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.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.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.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.SIZED 、Spliterator.SUBSIZED 、Spliterator.ORDERED 和 Spliterator.IMMUTABLE 。

参数：

array - 数组，假定在使用期间未修改

startInclusive - 要涵盖的第一个索引，包括在内

endExclusive - 索引紧接在最后一个索引之后

返回：

数组元素的拆分器

抛出：

ArrayIndexOutOfBoundsException - 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小

自从：

1.8

stream

public static <T> Stream <T> stream(T[] array)
            

返回以指定数组作为源的顺序 Stream 。

类型参数：

T - 数组元素的类型

参数：

array - 数组，假定在使用期间未修改

返回：

数组的 Stream

自从：

1.8

stream

public static <T> Stream <T> stream(T[] array, int startInclusive, int endExclusive)
            

返回以指定数组的指定范围作为其源的顺序 Stream 。

类型参数：

T - 数组元素的类型

参数：

array - 数组，假定在使用期间未修改

startInclusive - 要涵盖的第一个索引，包括在内

endExclusive - 索引紧接在最后一个索引之后

返回：

Stream 用于数组范围

抛出：

ArrayIndexOutOfBoundsException - 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小

自从：

1.8

stream

public static IntStream  stream(int[] array)
            

返回以指定数组作为源的顺序 IntStream 。

参数：

array - 数组，假定在使用期间未修改

返回：

数组的 IntStream

自从：

1.8

stream

public static IntStream  stream(int[] array, int startInclusive, int endExclusive)
            

返回以指定数组的指定范围作为其源的顺序 IntStream 。

参数：

array - 数组，假定在使用期间未修改

startInclusive - 要涵盖的第一个索引，包括在内

endExclusive - 索引紧接在最后一个索引之后

返回：

数组范围的 IntStream

抛出：

ArrayIndexOutOfBoundsException - 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小

自从：

1.8

stream

public static LongStream  stream(long[] array)
            

返回以指定数组作为源的顺序 LongStream 。

参数：

array - 数组，假定在使用期间未修改

返回：

LongStream 用于数组

自从：

1.8

stream

public static LongStream  stream(long[] array, int startInclusive, int endExclusive)
            

返回以指定数组的指定范围作为其源的顺序 LongStream 。

参数：

array - 数组，假定在使用期间未修改

startInclusive - 要涵盖的第一个索引，包括在内

endExclusive - 索引紧接在最后一个索引之后

返回：

LongStream 用于数组范围

抛出：

ArrayIndexOutOfBoundsException - 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小

自从：

1.8

stream

public static DoubleStream  stream(double[] array)
            

返回以指定数组作为源的顺序 DoubleStream 。

参数：

array - 数组，假定在使用期间未修改

返回：

一个 DoubleStream 用于数组

自从：

1.8

stream

public static DoubleStream  stream(double[] array, int startInclusive, int endExclusive)
            

返回以指定数组的指定范围作为其源的顺序 DoubleStream 。

参数：

array - 数组，假定在使用期间未修改

startInclusive - 要涵盖的第一个索引，包括在内

endExclusive - 索引紧接在最后一个索引之后

返回：

DoubleStream 用于数组范围

抛出：

ArrayIndexOutOfBoundsException - 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小

自从：

1.8

compare

public static int compare(boolean[] a, boolean[] b)
            

按字典顺序比较两个 boolean 数组。

如果这两个数组共享一个公共前缀，那么字典序比较是比较两个元素的结果，就像通过 Boolean.compare(boolean, boolean) 一样，在各自数组中的索引处，即前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(boolean[], boolean[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

比较与 equals 一致，更具体地说，以下内容适用于数组 a 和 b：

   Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
  

API 注意：

此方法的行为就像（对于非 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 一致，更具体地说，以下适用于指定范围 [aFromIndex , atoIndex ) 和 [bFromIndex , btoIndex ) 的数组 a 和 b：

   Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
     (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
  

API 注意：

此方法的行为就像：

   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.compare(byte, byte) 一样，在各自数组中的索引是前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(byte[], byte[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

比较与 equals 一致，更具体地说，以下内容适用于数组 a 和 b：

   Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
  

API 注意：

此方法的行为就像（对于非 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 一致，更具体地说，以下适用于指定范围 [aFromIndex , atoIndex ) 和 [bFromIndex , btoIndex ) 的数组 a 和 b：

   Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
     (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
  

API 注意：

此方法的行为就像：

   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.compareUnsigned(byte, byte) 一样，在各自数组中的索引处，即前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(byte[], byte[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

API 注意：

此方法的行为就像（对于非 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 注意：

此方法的行为就像：

   int i = Arrays.mismatch(a, aFromIndex, aToIndex,
               b, bFromIndex, bToIndex);
   if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
     return Byte.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
   return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
  

参数：

a - 第一个要比较的数组

aFromIndex - 要比较的第一个数组中第一个元素的索引（含）

aToIndex - 要比较的第一个数组中最后一个元素的索引（不包括）

b - 要比较的第二个数组

bFromIndex - 要比较的第二个数组中第一个元素的索引（含）

bToIndex - 要比较的第二个数组中最后一个元素的索引（不包括）

返回：

如果在指定范围内，第一个和第二个数组相等并且包含相同顺序的相同元素，则值为 0；小于 0 的值，如果在指定范围内，第一个数组按字典顺序小于第二个数组；和大于 0 的值，如果在指定范围内，第一个数组按字典顺序大于第二个数组

抛出：

IllegalArgumentException - 如果 aFromIndex > aToIndex 或如果 bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - 如果 aFromIndex < 0 or aToIndex > a.length 或如果 bFromIndex < 0 or bToIndex > b.length

NullPointerException - 如果任一数组为空

自从：

9

compare

public static int compare(short[] a, short[] b)
            

按字典顺序比较两个 short 数组。

如果这两个数组共享一个公共前缀，那么字典序比较是比较两个元素的结果，就像通过 Short.compare(short, short) 一样，在各自数组中的索引处，即前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(short[], short[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

比较与 equals 一致，更具体地说，以下内容适用于数组 a 和 b：

   Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
  

API 注意：

此方法的行为就像（对于非 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 一致，更具体地说，以下适用于指定范围 [aFromIndex , atoIndex ) 和 [bFromIndex , btoIndex ) 的数组 a 和 b：

   Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
     (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
  

API 注意：

此方法的行为就像：

   int i = Arrays.mismatch(a, aFromIndex, aToIndex,
               b, bFromIndex, bToIndex);
   if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
     return Short.compare(a[aFromIndex + i], b[bFromIndex + i]);
   return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
  

参数：

a - 第一个要比较的数组

aFromIndex - 要比较的第一个数组中第一个元素的索引（含）

aToIndex - 要比较的第一个数组中最后一个元素的索引（不包括）

b - 要比较的第二个数组

bFromIndex - 要比较的第二个数组中第一个元素的索引（含）

bToIndex - 要比较的第二个数组中最后一个元素的索引（不包括）

返回：

如果在指定范围内，第一个和第二个数组相等并且包含相同顺序的相同元素，则值为 0；小于 0 的值，如果在指定范围内，第一个数组按字典顺序小于第二个数组；和大于 0 的值，如果在指定范围内，第一个数组按字典顺序大于第二个数组

抛出：

IllegalArgumentException - 如果 aFromIndex > aToIndex 或如果 bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - 如果 aFromIndex < 0 or aToIndex > a.length 或如果 bFromIndex < 0 or bToIndex > b.length

NullPointerException - 如果任一数组是 null

自从：

9

compareUnsigned

public static int compareUnsigned(short[] a, short[] b)
            

按字典顺序比较两个 short 数组，在数字上将元素视为无符号。

如果这两个数组共享一个公共前缀，那么字典序比较是比较两个元素的结果，就像通过 Short.compareUnsigned(short, short) 一样，在各自数组中的索引是前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(short[], short[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

API 注意：

此方法的行为就像（对于非 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 注意：

此方法的行为就像：

   int i = Arrays.mismatch(a, aFromIndex, aToIndex,
               b, bFromIndex, bToIndex);
   if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
     return Short.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
   return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
  

参数：

a - 第一个要比较的数组

aFromIndex - 要比较的第一个数组中第一个元素的索引（含）

aToIndex - 要比较的第一个数组中最后一个元素的索引（不包括）

b - 要比较的第二个数组

bFromIndex - 要比较的第二个数组中第一个元素的索引（含）

bToIndex - 要比较的第二个数组中最后一个元素的索引（不包括）

返回：

如果在指定范围内，第一个和第二个数组相等并且包含相同顺序的相同元素，则值为 0；小于 0 的值，如果在指定范围内，第一个数组按字典顺序小于第二个数组；和大于 0 的值，如果在指定范围内，第一个数组按字典顺序大于第二个数组

抛出：

IllegalArgumentException - 如果 aFromIndex > aToIndex 或如果 bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - 如果 aFromIndex < 0 or aToIndex > a.length 或如果 bFromIndex < 0 or bToIndex > b.length

NullPointerException - 如果任一数组为空

自从：

9

compare

public static int compare(char[] a, char[] b)
            

按字典顺序比较两个 char 数组。

如果这两个数组共享一个公共前缀，那么字典序比较是比较两个元素的结果，就像通过 Character.compare(char, char) 一样，在各自数组中的索引是前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(char[], char[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

比较与 equals 一致，更具体地说，以下内容适用于数组 a 和 b：

   Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
  

API 注意：

此方法的行为就像（对于非 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 一致，更具体地说，以下适用于指定范围 [aFromIndex , atoIndex ) 和 [bFromIndex , btoIndex ) 的数组 a 和 b：

   Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
     (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
  

API 注意：

此方法的行为就像：

   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 数组。

如果这两个数组共享一个公共前缀，那么字典序比较是比较两个元素的结果，就像通过 Integer.compare(int, int) 一样，在各自数组中的索引是前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(int[], int[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

比较与 equals 一致，更具体地说，以下内容适用于数组 a 和 b：

   Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
  

API 注意：

此方法的行为就像（对于非 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 一致，更具体地说，以下分别适用于具有指定范围 [aFromIndex , atoIndex ) 和 [bFromIndex , btoIndex ) 的数组 a 和 b：

   Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
     (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
  

API 注意：

此方法的行为就像：

   int i = Arrays.mismatch(a, aFromIndex, aToIndex,
               b, bFromIndex, bToIndex);
   if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
     return Integer.compare(a[aFromIndex + i], b[bFromIndex + i]);
   return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
  

参数：

a - 第一个要比较的数组

aFromIndex - 要比较的第一个数组中第一个元素的索引（含）

aToIndex - 要比较的第一个数组中最后一个元素的索引（不包括）

b - 要比较的第二个数组

bFromIndex - 要比较的第二个数组中第一个元素的索引（含）

bToIndex - 要比较的第二个数组中最后一个元素的索引（不包括）

返回：

如果在指定范围内，第一个和第二个数组相等并且包含相同顺序的相同元素，则值为 0；小于 0 的值，如果在指定范围内，第一个数组按字典顺序小于第二个数组；和大于 0 的值，如果在指定范围内，第一个数组按字典顺序大于第二个数组

抛出：

IllegalArgumentException - 如果 aFromIndex > aToIndex 或如果 bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - 如果 aFromIndex < 0 or aToIndex > a.length 或如果 bFromIndex < 0 or bToIndex > b.length

NullPointerException - 如果任一数组是 null

自从：

9

compareUnsigned

public static int compareUnsigned(int[] a, int[] b)
            

按字典顺序比较两个 int 数组，在数字上将元素视为无符号。

如果这两个数组共享一个公共前缀，那么字典序比较是比较两个元素的结果，就像通过 Integer.compareUnsigned(int, int) 一样，在各自数组中的索引处，即前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(int[], int[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

API 注意：

此方法的行为就像（对于非 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 注意：

此方法的行为就像：

   int i = Arrays.mismatch(a, aFromIndex, aToIndex,
               b, bFromIndex, bToIndex);
   if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
     return Integer.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
   return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
  

参数：

a - 第一个要比较的数组

aFromIndex - 要比较的第一个数组中第一个元素的索引（含）

aToIndex - 要比较的第一个数组中最后一个元素的索引（不包括）

b - 要比较的第二个数组

bFromIndex - 要比较的第二个数组中第一个元素的索引（含）

bToIndex - 要比较的第二个数组中最后一个元素的索引（不包括）

返回：

如果在指定范围内，第一个和第二个数组相等并且包含相同顺序的相同元素，则值为 0；小于 0 的值，如果在指定范围内，第一个数组按字典顺序小于第二个数组；和大于 0 的值，如果在指定范围内，第一个数组按字典顺序大于第二个数组

抛出：

IllegalArgumentException - 如果 aFromIndex > aToIndex 或如果 bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - 如果 aFromIndex < 0 or aToIndex > a.length 或如果 bFromIndex < 0 or bToIndex > b.length

NullPointerException - 如果任一数组为空

自从：

9

compare

public static int compare(long[] a, long[] b)
            

按字典顺序比较两个 long 数组。

如果这两个数组共享一个公共前缀，那么字典序比较是比较两个元素的结果，就像通过 Long.compare(long, long) 一样，在各自数组中的索引是前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(long[], long[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

比较与 equals 一致，更具体地说，以下内容适用于数组 a 和 b：

   Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
  

API 注意：

此方法的行为就像（对于非 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 一致，更具体地说，以下适用于指定范围 [aFromIndex , atoIndex ) 和 [bFromIndex , btoIndex ) 的数组 a 和 b：

   Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
     (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
  

API 注意：

此方法的行为就像：

   int i = Arrays.mismatch(a, aFromIndex, aToIndex,
               b, bFromIndex, bToIndex);
   if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
     return Long.compare(a[aFromIndex + i], b[bFromIndex + i]);
   return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
  

参数：

a - 第一个要比较的数组

aFromIndex - 要比较的第一个数组中第一个元素的索引（含）

aToIndex - 要比较的第一个数组中最后一个元素的索引（不包括）

b - 要比较的第二个数组

bFromIndex - 要比较的第二个数组中第一个元素的索引（含）

bToIndex - 要比较的第二个数组中最后一个元素的索引（不包括）

返回：

如果在指定范围内，第一个和第二个数组相等并且包含相同顺序的相同元素，则值为 0；小于 0 的值，如果在指定范围内，第一个数组按字典顺序小于第二个数组；和大于 0 的值，如果在指定范围内，第一个数组按字典顺序大于第二个数组

抛出：

IllegalArgumentException - 如果 aFromIndex > aToIndex 或如果 bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - 如果 aFromIndex < 0 or aToIndex > a.length 或如果 bFromIndex < 0 or bToIndex > b.length

NullPointerException - 如果任一数组是 null

自从：

9

compareUnsigned

public static int compareUnsigned(long[] a, long[] b)
            

按字典顺序比较两个 long 数组，在数字上将元素视为无符号。

如果这两个数组共享一个公共前缀，那么字典序比较是比较两个元素的结果，就像通过 Long.compareUnsigned(long, long) 一样，在各自数组中的索引处，即前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(long[], long[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

API 注意：

此方法的行为就像（对于非 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 注意：

此方法的行为就像：

   int i = Arrays.mismatch(a, aFromIndex, aToIndex,
               b, bFromIndex, bToIndex);
   if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
     return Long.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
   return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
  

参数：

a - 第一个要比较的数组

aFromIndex - 要比较的第一个数组中第一个元素的索引（含）

aToIndex - 要比较的第一个数组中最后一个元素的索引（不包括）

b - 要比较的第二个数组

bFromIndex - 要比较的第二个数组中第一个元素的索引（含）

bToIndex - 要比较的第二个数组中最后一个元素的索引（不包括）

返回：

如果在指定范围内，第一个和第二个数组相等并且包含相同顺序的相同元素，则值为 0；小于 0 的值，如果在指定范围内，第一个数组按字典顺序小于第二个数组；和大于 0 的值，如果在指定范围内，第一个数组按字典顺序大于第二个数组

抛出：

IllegalArgumentException - 如果 aFromIndex > aToIndex 或如果 bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - 如果 aFromIndex < 0 or aToIndex > a.length 或如果 bFromIndex < 0 or bToIndex > b.length

NullPointerException - 如果任一数组为空

自从：

9

compare

public static int compare(float[] a, float[] b)
            

按字典顺序比较两个 float 数组。

如果这两个数组共享一个公共前缀，那么字典序比较是比较两个元素的结果，就像通过 Float.compare(float, float) 一样，在各自数组中的索引是前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(float[], float[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

比较与 equals 一致，更具体地说，以下内容适用于数组 a 和 b：

   Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
  

API 注意：

此方法的行为就像（对于非 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 一致，更具体地说，以下适用于指定范围 [aFromIndex , atoIndex ) 和 [bFromIndex , btoIndex ) 的数组 a 和 b：

   Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
     (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
  

API 注意：

此方法的行为就像：

   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.compare(double, double) 一样，在各自数组中的索引是前缀长度。否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(double[], double[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。

比较与 equals 一致，更具体地说，以下内容适用于数组 a 和 b：

   Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
  

API 注意：

此方法的行为就像（对于非 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 一致，更具体地说，以下分别适用于具有指定范围 [aFromIndex , atoIndex ) 和 [bFromIndex , btoIndex ) 的数组 a 和 b：

   Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
     (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
  

API 注意：

此方法的行为就像：

   int i = Arrays.mismatch(a, aFromIndex, aToIndex,
               b, bFromIndex, bToIndex);
   if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
     return Double.compare(a[aFromIndex + i], b[bFromIndex + i]);
   return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
  

参数：

a - 第一个要比较的数组

aFromIndex - 要比较的第一个数组中第一个元素的索引（含）

aToIndex - 要比较的第一个数组中最后一个元素的索引（不包括）

b - 要比较的第二个数组

bFromIndex - 要比较的第二个数组中第一个元素的索引（含）

bToIndex - 要比较的第二个数组中最后一个元素的索引（不包括）

返回：

如果在指定范围内，第一个和第二个数组相等并且包含相同顺序的相同元素，则值为 0；小于 0 的值，如果在指定范围内，第一个数组按字典顺序小于第二个数组；和大于 0 的值，如果在指定范围内，第一个数组按字典顺序大于第二个数组

抛出：

IllegalArgumentException - 如果 aFromIndex > aToIndex 或如果 bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - 如果 aFromIndex < 0 or aToIndex > a.length 或如果 bFromIndex < 0 or bToIndex > b.length

NullPointerException - 如果任一数组是 null

自从：

9

compare

public static <T extends Comparable <? super T>> int compare(T[] a, T[] b)
            

按字典顺序比较可比较元素内的两个 Object 数组。

如果两个数组共享一个公共前缀，则字典序比较是比较两个类型为 T 的元素在相应数组中索引为前缀长度的 i 处的结果，就好像通过：

   Comparator.nullsFirst(Comparator.<T>naturalOrder()).
     compare(a[i], b[i])
  

否则，一个数组是另一个数组的适当前缀，字典序比较是比较两个数组长度的结果。 （请参阅 mismatch(Object[], Object[]) 以了解通用和专有前缀的定义。）

null 数组引用在字典序上被认为小于非 null 数组引用。两个 null 数组引用被认为是相等的。 null 数组元素在字典序上被认为小于非 null 数组元素。两个 null 数组元素被认为是相等的。

比较与 equals 一致，更具体地说，以下内容适用于数组 a 和 b：

   Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
  

API 注意：

此方法的行为就像（对于非 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 一致，更具体地说，以下适用于指定范围 [aFromIndex , atoIndex ) 和 [bFromIndex , btoIndex ) 的数组 a 和 b：

   Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
     (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
  

API 注意：

此方法的行为就像（对于非 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 注意：

此方法的行为就像（对于非 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 注意：

此方法的行为就像（对于非 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（含）到较小数组的长度（含）之间。

如果两个数组共享一个公共前缀，则返回的索引是公共前缀的长度，这表明在各自数组中该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的适当前缀，则返回的索引是较小数组的长度，因此该索引仅对较大数组有效。否则，不存在不匹配。

如果以下表达式为真，则两个非 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 的公共前缀长度表示每个数组的第一个元素不匹配。

如果以下表达式为真，则两个非 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（含）到较小数组的长度（含）之间。

如果两个数组共享一个公共前缀，则返回的索引是公共前缀的长度，这表明在各自数组中该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的适当前缀，则返回的索引是较小数组的长度，因此该索引仅对较大数组有效。否则，不存在不匹配。

如果以下表达式为真，则两个非 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 的公共前缀长度表示每个数组的第一个元素不匹配。

如果以下表达式为真，则两个非 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（含）到较小数组的长度（含）之间。

如果两个数组共享一个公共前缀，则返回的索引是公共前缀的长度，这表明在各自数组中该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的适当前缀，则返回的索引是较小数组的长度，因此该索引仅对较大数组有效。否则，不存在不匹配。

如果以下表达式为真，则两个非 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 的公共前缀长度表示每个数组的第一个元素不匹配。

如果以下表达式为真，则两个非 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（含）到较小数组的长度（含）之间。

如果两个数组共享一个公共前缀，则返回的索引是公共前缀的长度，这表明在各自数组中该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的适当前缀，则返回的索引是较小数组的长度，因此该索引仅对较大数组有效。否则，不存在不匹配。

如果以下表达式为真，则两个非 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 的公共前缀长度表示每个数组的第一个元素不匹配。

如果以下表达式为真，则两个非 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（含）到较小数组的长度（含）之间。

如果两个数组共享一个公共前缀，则返回的索引是公共前缀的长度，这表明在各自数组中该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的适当前缀，则返回的索引是较小数组的长度，因此该索引仅对较大数组有效。否则，不存在不匹配。

如果以下表达式为真，则两个非 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 的公共前缀长度表示每个数组的第一个元素不匹配。

如果以下表达式为真，则两个非 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（含）到较小数组的长度（含）之间。

如果两个数组共享一个公共前缀，则返回的索引是公共前缀的长度，这表明在各自数组中该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的适当前缀，则返回的索引是较小数组的长度，因此该索引仅对较大数组有效。否则，不存在不匹配。

如果以下表达式为真，则两个非 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 的公共前缀长度表示每个数组的第一个元素不匹配。

如果以下表达式为真，则两个非 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（含）到较小数组的长度（含）之间。

如果两个数组共享一个公共前缀，则返回的索引是公共前缀的长度，这表明在各自数组中该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的适当前缀，则返回的索引是较小数组的长度，因此该索引仅对较大数组有效。否则，不存在不匹配。

如果以下表达式为真，则两个非 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 的公共前缀长度表示每个数组的第一个元素不匹配。

如果以下表达式为真，则两个非 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（含）到较小数组的长度（含）之间。

如果两个数组共享一个公共前缀，则返回的索引是公共前缀的长度，这表明在各自数组中该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的适当前缀，则返回的索引是较小数组的长度，因此该索引仅对较大数组有效。否则，不存在不匹配。

如果以下表达式为真，则两个非 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 的公共前缀长度表示每个数组的第一个元素不匹配。

如果以下表达式为真，则两个非 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（含）到较小数组的长度（含）之间。

如果两个数组共享一个公共前缀，则返回的索引是公共前缀的长度，这表明在各自数组中该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的适当前缀，则返回的索引是较小数组的长度，因此该索引仅对较大数组有效。否则，不存在不匹配。

如果以下表达式为真，则两个非 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 的公共前缀长度表示每个数组的第一个元素不匹配。

如果以下表达式为真，则两个非 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（含）到较小数组的长度（含）之间。

指定的比较器用于确定每个数组中的两个数组元素是否不相等。

如果两个数组共享一个公共前缀，则返回的索引是公共前缀的长度，这表明在各自数组中该索引处的两个元素之间存在不匹配。如果一个数组是另一个数组的适当前缀，则返回的索引是较小数组的长度，因此该索引仅对较大数组有效。否则，不存在不匹配。

如果以下表达式为真，则两个非 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 的公共前缀长度表示每个数组的第一个元素不匹配。

如果以下表达式为真，则两个非 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