Module java.base

Package java.util

Class Arrays

java.lang.Object

java.util.Arrays

       public final class Arrays extends Object
      

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

此类中的所有方法都会在指定的数组引用为null时抛出NullPointerException，除非另有说明。

此类中方法的文档包括对实现的简要描述。这些描述应被视为实现注释，而不是规范的一部分。实现者可以自由地替换其他算法，只要遵守规范本身即可（例如，sort(Object[])使用的算法不一定非要是归并排序，但必须是稳定的）。

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

自版本:

1.2

Method Summary

Modifier and Type	Method	Description
static <T> List<T>	asList(T... a)	返回由指定数组支持的固定大小列表。
static int	binarySearch(byte[] a, byte key)	使用二分搜索算法在指定的字节数组中搜索指定值。
static int	binarySearch(byte[] a, int fromIndex, int toIndex, byte key)	使用二分搜索算法在指定字节数组的范围内搜索指定值。
static int	binarySearch(char[] a, char key)	使用二分搜索算法在指定字符数组中搜索指定值。
static int	binarySearch(char[] a, int fromIndex, int toIndex, char key)	使用二分搜索算法在指定字符数组的范围内搜索指定值。
static int	binarySearch(double[] a, double key)	使用二分搜索算法在指定双精度数组中搜索指定值。
static int	binarySearch(double[] a, int fromIndex, int toIndex, double key)	使用二分搜索算法在指定双精度数组的范围内搜索指定值。
static int	binarySearch(float[] a, float key)	使用二分搜索算法在指定浮点数数组中搜索指定值。
static int	binarySearch(float[] a, int fromIndex, int toIndex, float key)	使用二分搜索算法在指定浮点数数组的范围内搜索指定值。
static int	binarySearch(int[] a, int key)	使用二分搜索算法在指定整数数组中搜索指定值。
static int	binarySearch(int[] a, int fromIndex, int toIndex, int key)	使用二分搜索算法在指定整数数组的范围内搜索指定值。
static int	binarySearch(long[] a, int fromIndex, int toIndex, long key)	使用二分搜索算法在指定长整型数组的范围内搜索指定值。
static int	binarySearch(long[] a, long key)	使用二分搜索算法在指定长整型数组中搜索指定值。
static int	binarySearch(short[] a, int fromIndex, int toIndex, short key)	使用二分搜索算法在指定短整型数组的范围内搜索指定值。
static int	binarySearch(short[] a, short key)	使用二分搜索算法在指定短整型数组中搜索指定值。
static int	binarySearch(Object[] a, int fromIndex, int toIndex, Object key)	使用二分搜索算法在指定对象数组的范围内搜索指定对象。
static int	binarySearch(Object[] a, Object key)	使用二分搜索算法在指定对象数组中搜索指定对象。
static <T> int	binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)	使用二分搜索算法在指定数组的范围内搜索指定对象。
static <T> int	binarySearch(T[] a, T key, Comparator<? super T> c)	使用二分搜索算法在指定数组中搜索指定对象。
static int	compare(boolean[] a, boolean[] b)	按字典顺序比较两个boolean数组。
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)	如果两个指定的布尔数组彼此相等，则返回true。
static boolean	equals(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)	如果两个指定的布尔数组在指定范围内彼此相等，则返回true。
static boolean	equals(byte[] a, byte[] a2)	如果两个指定的字节数组彼此相等，则返回true。
static boolean	equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)	如果两个指定的字节数组在指定范围内彼此相等，则返回true。
static boolean	equals(char[] a, char[] a2)	如果两个指定的字符数组彼此相等，则返回true。
static boolean	equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)	如果两个指定的字符数组在指定范围内彼此相等，则返回true。
static boolean	equals(double[] a, double[] a2)	如果两个指定的双精度数组彼此相等，则返回true。
static boolean	equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)	如果两个指定的双精度数组在指定范围内彼此相等，则返回true。
static boolean	equals(float[] a, float[] a2)	如果两个指定的浮点数数组彼此相等，则返回true。
static boolean	equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)	如果两个指定的浮点数数组在指定范围内彼此相等，则返回true。
static boolean	equals(int[] a, int[] a2)	如果两个指定的整数数组彼此相等，则返回true。
static boolean	equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)	如果两个指定的整数数组在指定范围内彼此相等，则返回true。
static boolean	equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)	如果两个指定的长整型数组在指定范围内彼此相等，则返回true。
static boolean	equals(long[] a, long[] a2)	如果两个指定的长整型数组彼此相等，则返回true。
static boolean	equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)	如果两个指定的短整型数组在指定范围内彼此相等，则返回true。
static boolean	equals(short[] a, short[] a2)	如果两个指定的短整型数组彼此相等，则返回true。
static boolean	equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)	如果两个指定的对象数组在指定范围内彼此相等，则返回true。
static boolean	equals(Object[] a, Object[] a2)	返回true如果两个指定的对象数组彼此相等。
static <T> boolean	equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)	如果两个指定的对象数组在指定范围内彼此相等，则返回true。
static <T> boolean	equals(T[] a, T[] a2, Comparator<? super T> cmp)	返回true如果两个指定的对象数组彼此相等。
static void	fill(boolean[] a, boolean val)	将指定的布尔值分配给指定布尔数组的每个元素。
static void	fill(boolean[] a, int fromIndex, int toIndex, boolean val)	将指定的布尔值分配给指定布尔数组的指定范围内的每个元素。
static void	fill(byte[] a, byte val)	将指定的字节值分配给指定字节数组的每个元素。
static void	fill(byte[] a, int fromIndex, int toIndex, byte val)	将指定的字节值分配给指定字节数组的指定范围内的每个元素。
static void	fill(char[] a, char val)	将指定的字符值分配给指定字符数组的每个元素。
static void	fill(char[] a, int fromIndex, int toIndex, char val)	将指定的字符值分配给指定字符数组的指定范围内的每个元素。
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)	将指定的整数值分配给指定整数数组的每个元素。
static void	fill(int[] a, int fromIndex, int toIndex, int val)	将指定的整数值分配给指定整数数组的指定范围内的每个元素。
static void	fill(long[] a, int fromIndex, int toIndex, long val)	将指定的长整型值分配给指定长整型数组的指定范围内的每个元素。
static void	fill(long[] a, long val)	将指定的长整型值分配给指定长整型数组的每个元素。
static void	fill(short[] a, int fromIndex, int toIndex, short val)	将指定的短整型值分配给指定短整型数组的指定范围内的每个元素。
static void	fill(short[] a, short val)	将指定的短整型值分配给指定短整型数组的每个元素。
static void	fill(Object[] a, int fromIndex, int toIndex, Object val)	将指定的对象引用分配给指定对象数组的指定范围内的每个元素。
static void	fill(Object[] a, Object val)	将指定的对象引用分配给指定对象数组的每个元素。
static int	hashCode(boolean[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(byte[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(char[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(double[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(float[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(int[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(long[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(short[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(Object[] a)	根据指定数组的内容返回哈希码。
static int	mismatch(boolean[] a, boolean[] b)	查找并返回两个boolean数组之间第一个不匹配的索引，如果没有找到不匹配则返回-1。
static int	mismatch(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)	在指定范围内查找并返回两个boolean数组之间第一个不匹配的相对索引，如果没有找到不匹配则返回-1。
static int	mismatch(byte[] a, byte[] b)	查找并返回两个byte数组之间第一个不匹配的索引，如果没有找到不匹配则返回-1。
static int	mismatch(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)	在指定范围内查找并返回两个byte数组之间第一个不匹配的相对索引，如果没有找到不匹配则返回-1。
static int	mismatch(char[] a, char[] b)	查找并返回两个char数组之间第一个不匹配的索引，如果没有找到不匹配则返回-1。
static int	mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)	在指定范围内查找并返回两个char数组之间第一个不匹配的相对索引，如果没有找到不匹配则返回-1。
static int	mismatch(double[] a, double[] b)	查找并返回两个double数组之间第一个不匹配的索引，如果没有找到不匹配则返回-1。
static int	mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)	在指定范围内查找并返回两个double数组之间第一个不匹配的相对索引，如果没有找到不匹配则返回-1。
static int	mismatch(float[] a, float[] b)	查找并返回两个float数组之间第一个不匹配的索引，如果没有找到不匹配则返回-1。
static int	mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)	在指定范围内查找并返回两个float数组之间第一个不匹配的相对索引，如果没有找到不匹配则返回-1。
static int	mismatch(int[] a, int[] b)	查找并返回两个int数组之间第一个不匹配的索引，如果没有找到不匹配则返回-1。
static int	mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)	在指定范围内查找并返回两个int数组之间第一个不匹配的相对索引，如果没有找到不匹配则返回-1。
static int	mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)	在指定范围内查找并返回两个long数组之间第一个不匹配的相对索引，如果没有找到不匹配则返回-1。
static int	mismatch(long[] a, long[] b)	查找并返回两个long数组之间第一个不匹配的索引，如果没有找到不匹配则返回-1。
static int	mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)	在指定范围内查找并返回两个short数组之间第一个不匹配的相对索引，如果没有找到不匹配则返回-1。
static int	mismatch(short[] a, short[] b)	查找并返回两个short数组之间第一个不匹配的索引，如果没有找到不匹配则返回-1。
static int	mismatch(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)	在指定范围内查找并返回两个Object数组之间第一个不匹配的相对索引，如果没有找到不匹配则返回-1。
static int	mismatch(Object[] a, Object[] b)	查找并返回两个Object数组之间第一个不匹配的索引，如果没有找到不匹配则返回-1。
static <T> int	mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)	在指定范围内查找并返回两个Object数组之间第一个不匹配的相对索引，如果没有找到不匹配则返回-1。
static <T> int	mismatch(T[] a, T[] b, Comparator<? super T> cmp)	查找并返回两个Object数组之间第一个不匹配的索引，如果没有找到不匹配则返回-1。
static void	parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)	对数组的给定子范围执行parallelPrefix(double[], DoubleBinaryOperator)。
static void	parallelPrefix(double[] array, DoubleBinaryOperator op)	并行地在原地对给定数组的每个元素进行累积，使用提供的函数。
static void	parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)	对数组的给定子范围执行parallelPrefix(int[], IntBinaryOperator)。
static void	parallelPrefix(int[] array, IntBinaryOperator op)	并行地在原地对给定数组的每个元素进行累积，使用提供的函数。
static void	parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)	对数组的给定子范围执行parallelPrefix(long[], LongBinaryOperator)。
static void	parallelPrefix(long[] array, LongBinaryOperator op)	并行地在原地对给定数组的每个元素进行累积，使用提供的函数。
static <T> void	parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)	对数组的给定子范围执行parallelPrefix(Object[], BinaryOperator)。
static <T> void	parallelPrefix(T[] array, BinaryOperator<T> op)	并行地在原地对给定数组的每个元素进行累积，使用提供的函数。
static void	parallelSetAll(double[] array, IntToDoubleFunction generator)	使用提供的生成器函数并行地设置指定数组的所有元素。
static void	parallelSetAll(int[] array, IntUnaryOperator generator)	使用提供的生成器函数并行地设置指定数组的所有元素。
static void	parallelSetAll(long[] array, IntToLongFunction generator)	使用提供的生成器函数并行地设置指定数组的所有元素。
static <T> void	parallelSetAll(T[] array, IntFunction<? extends T> generator)	使用提供的生成器函数并行地设置指定数组的所有元素。
static void	parallelSort(byte[] a)	将指定数组按升序数字顺序排序。
static void	parallelSort(byte[] a, int fromIndex, int toIndex)	将数组的指定范围按升序数字顺序排序。
static void	parallelSort(char[] a)	将指定数组按升序数字顺序排序。
static void	parallelSort(char[] a, int fromIndex, int toIndex)	将数组的指定范围按升序数字顺序排序。
static void	parallelSort(double[] a)	将指定数组按升序数字顺序排序。
static void	parallelSort(double[] a, int fromIndex, int toIndex)	将数组的指定范围按升序数字顺序排序。
static void	parallelSort(float[] a)	将指定数组按升序数字顺序排序。
static void	parallelSort(float[] a, int fromIndex, int toIndex)	将数组的指定范围按升序数字顺序排序。
static void	parallelSort(int[] a)	将指定数组按升序数字顺序排序。
static void	parallelSort(int[] a, int fromIndex, int toIndex)	将数组的指定范围按升序数字顺序排序。
static void	parallelSort(long[] a)	将指定数组按升序数字顺序排序。
static void	parallelSort(long[] a, int fromIndex, int toIndex)	将数组的指定范围按升序数字顺序排序。
static void	parallelSort(short[] a)	将指定数组按升序数字顺序排序。
static void	parallelSort(short[] a, int fromIndex, int toIndex)	将数组的指定范围按升序数字顺序排序。
static <T extends Comparable<? super T>> void	parallelSort(T[] a)	根据其元素的自然顺序，将指定的对象数组按升序排序。
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)	返回指定数组内容的字符串表示形式。

Methods declared in class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details

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 - 要排序的数组

自Java版本:

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

自Java版本:

1.8

parallelSort

             public static void parallelSort(char[] a)
            

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

实现注意事项:

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

参数:

a - 要排序的数组

自Java版本:

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和e2，e1.compareTo(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和e2，e1.compareTo(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)
            

Sorts the specified array of objects according to the order induced by the specified comparator. All elements in the array must be mutually comparable by the specified comparator (that is, c.compare(e1, e2) must not throw a ClassCastException for any elements e1 and e2 in the array).

This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort.

Implementation Note:

The sorting algorithm is a parallel sort-merge that breaks the array into sub-arrays that are themselves sorted and then merged. When the sub-array length reaches a minimum granularity, the sub-array is sorted using the appropriate Arrays.sort method. If the length of the specified array is less than the minimum granularity, then it is sorted using the appropriate Arrays.sort method. The algorithm requires a working space no greater than the size of the original array. The ForkJoin common pool is used to execute any parallel tasks.

Type Parameters:

T - the class of the objects to be sorted

Parameters:

a - the array to be sorted

cmp - the comparator to determine the order of the array. A null value indicates that the elements' natural ordering should be used.

Throws:

ClassCastException - if the array contains elements that are not mutually comparable using the specified comparator

IllegalArgumentException - (optional) if the comparator is found to violate the Comparator contract

Since:

1.8

parallelSort

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

Sorts the specified range of the specified array of objects according to the order induced by the specified comparator. The range to be sorted extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be sorted is empty.) All elements in the range must be mutually comparable by the specified comparator (that is, c.compare(e1, e2) must not throw a ClassCastException for any elements e1 and e2 in the range).

This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort.

Implementation Note:

The sorting algorithm is a parallel sort-merge that breaks the array into sub-arrays that are themselves sorted and then merged. When the sub-array length reaches a minimum granularity, the sub-array is sorted using the appropriate Arrays.sort method. If the length of the specified array is less than the minimum granularity, then it is sorted using the appropriate Arrays.sort method. The algorithm requires a working space no greater than the size of the specified range of the original array. The ForkJoin common pool is used to execute any parallel tasks.

Type Parameters:

T - the class of the objects to be sorted

Parameters:

a - the array to be sorted

fromIndex - the index of the first element (inclusive) to be sorted

toIndex - the index of the last element (exclusive) to be sorted

cmp - the comparator to determine the order of the array. A null value indicates that the elements' natural ordering should be used.

Throws:

IllegalArgumentException - if fromIndex > toIndex or (optional) if the natural ordering of the array elements is found to violate the Comparable contract

ArrayIndexOutOfBoundsException - if fromIndex < 0 or toIndex > a.length

ClassCastException - if the array contains elements that are not mutually comparable (for example, strings and integers).

Since:

1.8

sort

             public static void sort(Object[] a)
            

对指定的对象数组按照其元素的自然顺序进行升序排序。数组中的所有元素必须实现Comparable接口。此外，数组中的所有元素必须是可相互比较的（即，对于数组中的任何元素e1和e2，e1.compareTo(e2)不能抛出ClassCastException）。

此排序保证是稳定的：相等的元素不会因排序而重新排序。

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

该实现充分利用了输入数组的升序和降序，并且可以利用同一输入数组的不同部分的升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。

该实现是从Tim Peters的Python列表排序（ TimSort）中改编的。它使用了Peter McIlroy的“乐观排序和信息论复杂性”中的技术，发表于1993年1月第四届ACM-SIAM离散算法年会论文集，第467-474页。

参数：

a - 要排序的数组

抛出：

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

IllegalArgumentException - （可选）如果发现数组元素的自然顺序违反了Comparable合同

sort

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

对指定的对象数组的指定范围按照其元素的自然顺序进行升序排序。要排序的范围从索引fromIndex（包括）扩展到索引toIndex（不包括）。（如果fromIndex==toIndex，则要排序的范围为空。）此范围中的所有元素必须实现Comparable接口。此外，此范围中的所有元素必须是可相互比较的（即，对于范围中的任何元素e1和e2，e1.compareTo(e2)不能抛出ClassCastException）。

此排序保证是稳定的：相等的元素不会因排序而重新排序。

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

该实现充分利用了输入数组的升序和降序，并且可以利用同一输入数组的不同部分的升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。

该实现是从Tim Peters的Python列表排序（ TimSort）中改编的。它使用了Peter McIlroy的“乐观排序和信息论复杂性”中的技术，发表于1993年1月第四届ACM-SIAM离散算法年会论文集，第467-474页。

参数：

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)
            

根据指定比较器引起的顺序对指定的对象数组进行排序。数组中的所有元素必须通过指定的比较器是可相互比较的（即，对于数组中的任何元素e1和e2，c.compare(e1, e2)不能抛出ClassCastException）。

此排序保证是稳定的：相等的元素不会因排序而重新排序。

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

该实现充分利用了输入数组的升序和降序，并且可以利用同一输入数组的不同部分的升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。

该实现是从Tim Peters的Python列表排序（ TimSort）中改编的。它使用了Peter McIlroy的“乐观排序和信息论复杂性”中的技术，发表于1993年1月第四届ACM-SIAM离散算法年会论文集，第467-474页。

类型参数：

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，则要排序的范围为空。）此范围中的所有元素必须通过指定的比较器是可相互比较的（即，对于范围中的任何元素e1和e2，c.compare(e1, e2)不能抛出ClassCastException）。

此排序保证是稳定的：相等的元素不会因排序而重新排序。

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

该实现充分利用了输入数组的升序和降序，并且可以利用同一输入数组的不同部分的升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。

该实现是从Tim Peters的Python列表排序（ TimSort）中改编的。它使用了Peter McIlroy的“乐观排序和信息论复杂性”中的技术，发表于1993年1月第四届ACM-SIAM离散算法年会论文集，第467-474页。

类型参数：

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 - 如果指定的数组或函数为null

自：

1.8

parallelPrefix

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

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

类型参数：

T - 数组中对象的类

参数：

array - 数组

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

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

op - 一个无副作用的可关联函数，用于执行累积操作

抛出：

IllegalArgumentException - 如果fromIndex > toIndex

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

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

自：

1.8

parallelPrefix

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

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

参数：

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

op - 一个无副作用的可关联函数，用于执行累积操作

抛出：

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

自：

1.8

parallelPrefix

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

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

参数：

array - 数组

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

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

op - 一个无副作用的可关联函数，用于执行累积操作

抛出：

IllegalArgumentException - 如果fromIndex > toIndex

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

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

自：

1.8

parallelPrefix

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

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

由于浮点运算可能不是严格关联的，返回的结果可能与顺序执行操作时获得的值不同。

参数：

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

op - 一个无副作用的函数，用于执行累积操作

抛出：

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

自：

1.8

parallelPrefix

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

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

参数：

array - 数组

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

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

op - 一个无副作用的可关联函数，用于执行累积操作

抛出：

IllegalArgumentException - 如果fromIndex > toIndex

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

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

自：

1.8

parallelPrefix

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

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

参数：

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

op - 一个无副作用的可关联函数，用于执行累积操作

抛出：

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

自：

1.8

parallelPrefix

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

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

参数：

array - 数组

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

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

op - 一个无副作用的可关联函数，用于执行累积操作

抛出：

IllegalArgumentException - 如果fromIndex > toIndex

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

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

自：

1.8

binarySearch

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

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

参数：

a - 要搜索的数组

key - 要搜索的值

返回：

如果数组中包含搜索键，则返回搜索键的索引；否则返回(-(插入点) - 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 - 要搜索的值

返回：

如果搜索键包含在指定范围内的数组中，则返回搜索键的索引；否则返回(-(插入点) - 1)。插入点被定义为键将插入数组的位置：范围中大于键的第一个元素的索引，或者如果范围中的所有元素都小于指定的键，则为toIndex。请注意，这保证返回值仅在找到键时为>= 0。

抛出：

IllegalArgumentException - 如果fromIndex > toIndex

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

自：

1.6

binarySearch

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

使用二分搜索算法在指定的int数组中搜索指定值。在调用此方法之前，数组必须经过排序（如通过sort(int[])方法）。如果未排序，则结果是未定义的。如果数组包含多个具有指定值的元素，则不能保证找到哪个元素。

参数:

a - 要搜索的数组

key - 要搜索的值

返回:

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

binarySearch

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

使用二分搜索算法在指定的int数组范围内搜索指定值。在调用此方法之前，范围必须经过排序（例如通过sort(int[], int, int)方法）。如果未排序，则结果是未定义的。如果范围包含多个具有指定值的元素，则不能保证找到哪个元素。

参数:

a - 要搜索的数组

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

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

key - 要搜索的值

返回:

如果数组中包含指定范围内的搜索键，则返回搜索键的索引；否则返回(-(插入点) - 1)。插入点被定义为将键插入数组的位置：范围内大于键的第一个元素的索引，或者如果范围内的所有元素都小于指定的键，则为toIndex。请注意，这保证返回值仅在找到键时为 >= 0。

抛出:

IllegalArgumentException - 如果fromIndex > toIndex

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

自版本:

1.6

binarySearch

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

使用二分搜索算法在指定的short数组范围内搜索指定值。在调用此方法之前，范围必须经过排序（例如通过sort(short[], int, int)方法）。如果未排序，则结果是未定义的。如果范围包含多个具有指定值的元素，则不能保证找到哪个元素。

参数:

a - 要搜索的数组

key - 要搜索的值

返回:

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

binarySearch

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

使用二分搜索算法在指定的short数组范围内搜索指定值。在调用此方法之前，范围必须经过排序（例如通过sort(short[], int, int)方法）。如果未排序，则结果是未定义的。如果范围包含多个具有指定值的元素，则不能保证找到哪个元素。

参数:

a - 要搜索的数组

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

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

key - 要搜索的值

返回:

如果数组中包含指定范围内的搜索键，则返回搜索键的索引；否则返回(-(插入点) - 1)。插入点被定义为将键插入数组的位置：范围内大于键的第一个元素的索引，或者如果范围内的所有元素都小于指定的键，则为toIndex。请注意，这保证返回值仅在找到键时为 >= 0。

抛出:

IllegalArgumentException - 如果fromIndex > toIndex

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

自版本:

1.6

binarySearch

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

使用二分搜索算法在指定的char数组中搜索指定值。在调用此方法之前，数组必须经过排序（例如通过sort(char[])方法）。如果未排序，则结果是未定义的。如果数组包含多个具有指定值的元素，则不能保证找到哪个元素。

参数:

a - 要搜索的数组

key - 要搜索的值

返回:

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

binarySearch

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

使用二分搜索算法在指定的char数组范围内搜索指定值。在调用此方法之前，范围必须经过排序（例如通过sort(char[], int, int)方法）。如果未排序，则结果是未定义的。如果范围包含多个具有指定值的元素，则不能保证找到哪个元素。

参数:

a - 要搜索的数组

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

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

key - 要搜索的值

返回:

如果数组中包含指定范围内的搜索键，则返回搜索键的索引；否则返回(-(插入点) - 1)。插入点被定义为将键插入数组的位置：范围内大于键的第一个元素的索引，或者如果范围内的所有元素都小于指定的键，则为toIndex。请注意，这保证返回值仅在找到键时为 >= 0。

抛出:

IllegalArgumentException - 如果fromIndex > toIndex

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

自版本:

1.6

binarySearch

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

使用二分搜索算法在指定的byte数组中搜索指定值。在调用此方法之前，数组必须经过排序（例如通过sort(byte[])方法）。如果未排序，则结果是未定义的。如果数组包含多个具有指定值的元素，则不能保证找到哪个元素。

参数:

a - 要搜索的数组

key - 要搜索的值

返回:

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

binarySearch

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

使用二分搜索算法在指定的byte数组范围内搜索指定值。在调用此方法之前，范围必须经过排序（例如通过sort(byte[], int, int)方法）。如果未排序，则结果是未定义的。如果范围包含多个具有指定值的元素，则不能保证找到哪个元素。

参数:

a - 要搜索的数组

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

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

key - 要搜索的值

返回:

如果数组中包含指定范围内的搜索键，则返回搜索键的索引；否则返回(-(插入点) - 1)。插入点被定义为将键插入数组的位置：范围内大于键的第一个元素的索引，或者如果范围内的所有元素都小于指定的键，则为toIndex。请注意，这保证返回值仅在找到键时为 >= 0。

抛出:

IllegalArgumentException - 如果fromIndex > toIndex

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

自版本:

1.6

binarySearch

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

使用二分搜索算法在指定的double数组中搜索指定值。在调用此方法之前，数组必须经过排序（例如通过sort(double[])方法）。如果未排序，则结果是未定义的。如果数组包含多个具有指定值的元素，则不能保证找到哪个元素。此方法将所有NaN值视为等效且相等。

参数:

a - 要搜索的数组

key - 要搜索的值

返回:

如果数组中包含搜索键，则返回搜索键的索引；否则返回(-(插入点) - 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 - 要搜索的值

返回:

如果数组中包含指定范围内的搜索键，则返回搜索键的索引；否则返回(-(插入点) - 1)。插入点被定义为将键插入数组的位置：范围内大于键的第一个元素的索引，或者如果范围内的所有元素都小于指定的键，则为toIndex。请注意，这保证返回值仅在找到键时为 >= 0。

抛出:

IllegalArgumentException - 如果fromIndex > toIndex

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

自版本:

1.6

binarySearch

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

使用二分搜索算法在指定的浮点数数组中搜索指定值。在调用此方法之前，数组必须经过排序（例如通过sort(float[])方法）。如果未排序，则结果是未定义的。如果数组包含多个具有指定值的元素，则不能保证找到哪个元素。此方法将所有NaN值视为等效和相等。

参数:

a - 要搜索的数组

key - 要搜索的值

返回:

如果数组中包含搜索键，则返回搜索键的索引；否则返回(-(插入点) - 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 - 要搜索的值

返回:

如果数组中包含指定范围内的搜索键，则返回搜索键的索引；否则返回(-(插入点) - 1)。插入点被定义为将键插入数组的位置：范围内大于键的第一个元素的索引，或者如果范围内的所有元素都小于指定的键，则为toIndex。请注意，这保证返回值仅在找到键时为 >= 0。

抛出:

IllegalArgumentException - 如果fromIndex > toIndex

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

自版本:

1.6

binarySearch

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

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

参数:

a - 要搜索的数组

key - 要搜索的值

返回:

如果数组中包含搜索键，则返回搜索键的索引；否则返回(-(插入点) - 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 - 要搜索的值

返回:

如果数组中包含指定范围内的搜索键，则返回搜索键的索引；否则返回(-(插入点) - 1)。插入点被定义为将键插入数组的位置：范围内大于键的第一个元素的索引，或者如果范围内的所有元素都小于指定的键，则为toIndex。请注意，这保证返回值仅在找到键时为 >= 0。

抛出:

ClassCastException - 如果搜索键与指定范围内数组的元素不可比较。

IllegalArgumentException - 如果fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果fromIndex < 0 或 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值表示应使用元素的自然顺序。

返回:

如果数组中包含搜索键，则返回搜索键的索引；否则返回(-(插入点) - 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 值表示应使用元素的自然顺序。

返回:

如果搜索键包含在指定范围内的数组中，则返回搜索键的索引；否则返回(-(插入点) - 1)。 插入点 定义为键将插入数组的位置：范围内第一个大于键的元素的索引，或者如果范围内的所有元素都小于指定键，则为toIndex。请注意，这保证了仅当找到键时返回值将是 >= 0。

抛出:

ClassCastException - 如果范围包含使用指定比较器不是相互可比较的元素，或者搜索键与使用此比较器在范围内的元素不可比较。

IllegalArgumentException - 如果fromIndex > toIndex

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

自从:

1.6

equals

             public static boolean equals(long[] a, long[] a2)
            

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

参数:

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

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

返回:

如果两个数组相等，则返回true

equals

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

如果两个指定的long数组在指定范围内相等，则返回true。

如果每个范围覆盖的元素数量相同，并且两个数组中指定范围内的对应元素对相等，则认为两个数组相等。换句话说，如果它们以相同的顺序包含相同的元素，则两个数组相等。

参数:

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

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

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

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

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

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

返回:

如果两个数组在指定范围内相等，则返回true

抛出:

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

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

NullPointerException - 如果任一数组为null

自从:

9

equals

             public static boolean equals(int[] a, int[] a2)
            

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

参数:

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

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

返回:

如果两个数组相等，则返回true

equals

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

如果两个指定的int数组在指定范围内相等，则返回true。

如果每个范围覆盖的元素数量相同，并且两个数组中指定范围内的对应元素对相等，则认为两个数组相等。换句话说，如果它们以相同的顺序包含相同的元素，则两个数组相等。

参数:

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

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

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

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

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

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

返回:

如果两个数组在指定范围内相等，则返回true

抛出:

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

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

NullPointerException - 如果任一数组为null

自从:

9

equals

             public static boolean equals(short[] a, short[] a2)
            

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

参数:

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

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

返回:

如果两个数组相等，则返回true

equals

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

如果两个指定的short数组在指定范围内相等，则返回true。

如果每个范围覆盖的元素数量相同，并且两个数组中指定范围内的对应元素对相等，则认为两个数组相等。换句话说，如果它们以相同的顺序包含相同的元素，则两个数组相等。

参数:

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

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

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

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

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

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

返回:

如果两个数组在指定范围内相等，则返回true

抛出:

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

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

NullPointerException - 如果任一数组为null

自从:

9

equals

             public static boolean equals(char[] a, char[] a2)
            

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

参数:

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

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

返回:

如果两个数组相等，则返回true

equals

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

如果两个指定的char数组在指定范围内相等，则返回true。

如果每个范围覆盖的元素数量相同，并且两个数组中指定范围内的对应元素对相等，则认为两个数组相等。换句话说，如果它们以相同的顺序包含相同的元素，则两个数组相等。

参数:

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

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

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

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

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

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

返回:

如果两个数组在指定范围内相等，则返回true

抛出:

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

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

NullPointerException - 如果任一数组为null

自版本:

9

equals

             public static boolean equals(byte[] a, byte[] a2)
            

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

参数:

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

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

返回:

如果两个数组相等，则返回true

equals

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

如果两个指定范围内的字节数组彼此相等，则返回true。

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

参数:

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

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

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

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

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

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

返回:

如果两个数组在指定范围内相等，则返回true

抛出:

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

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

NullPointerException - 如果任一数组为null

自版本:

9

equals

             public static boolean equals(boolean[] a, boolean[] a2)
            

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

参数:

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

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

返回:

如果两个数组相等，则返回true

equals

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

如果两个指定范围内的布尔数组彼此相等，则返回true。

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

参数:

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

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

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

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

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

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

返回:

如果两个数组在指定范围内相等，则返回true

抛出:

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

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

NullPointerException - 如果任一数组为null

自版本:

9

equals

             public static boolean equals(double[] a, double[] a2)
            

如果两个指定的双精度数组彼此相等，则返回true。如果两个数组包含相同数量的元素，并且两个数组中对应的元素对都相等，则认为两个数组相等。换句话说，如果两个数组以相同顺序包含相同元素，则它们相等。此外，如果两个数组引用都为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)
            

如果两个指定范围内的双精度数组彼此相等，则返回true。

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

两个双精度数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或aToIndex > a.length或者bFromIndex < 0或bToIndex > b.length

NullPointerException - 如果任一数组为null

自版本:

9

参见:

• Double.equals(Object)

equals

             public static boolean equals(float[] a, float[] a2)
            

如果两个指定的浮点数数组彼此相等，则返回true。如果两个数组包含相同数量的元素，并且两个数组中对应的元素对都相等，则认为两个数组相等。换句话说，如果两个数组以相同顺序包含相同元素，则它们相等。此外，如果两个数组引用都为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)
            

返回true，如果两个指定范围内的浮点数数组相等。

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

如果两个浮点数 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 或 aToIndex > a.length 或 bFromIndex < 0 或 bToIndex > b.length

NullPointerException - 如果任一数组为 null

自版本:

9

参见:

• Float.equals(Object)

equals

             public static boolean equals(Object[] a, Object[] a2)
            

返回true，如果两个指定的对象数组相等。如果两个数组包含相同数量的元素，并且两个数组中对应的元素对相等，则认为两个数组相等。两个对象 e1 和 e2 如果 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)
            

返回true，如果两个指定范围内的对象数组相等。

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

如果两个对象 e1 和 e2 如果 Objects.equals(e1, e2) 则被认为是相等的。

参数:

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

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

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

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

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

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

返回:

如果两个数组在指定范围内相等，则返回 true

抛出:

IllegalArgumentException - 如果 aFromIndex > aToIndex 或 bFromIndex > bToIndex

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

NullPointerException - 如果任一数组为 null

自版本:

9

equals

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

返回true，如果两个指定的对象数组相等。

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

如果两个对象 e1 和 e2 如果给定指定的比较器，则 cmp.compare(e1, e2) == 0 则被认为是相等的。

类型参数:

T - 数组元素的类型

参数:

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

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

cmp - 用于比较数组元素的比较器

返回:

如果两个数组相等，则返回 true

抛出:

NullPointerException - 如果比较器为 null

自版本:

9

equals

             public static <T> boolean equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)
            

返回true，如果两个指定范围内的对象数组相等。

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

如果两个对象 e1 和 e2 如果给定指定的比较器，则 cmp.compare(e1, e2) == 0 则被认为是相等的。

类型参数:

T - 数组元素的类型

参数:

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

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

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

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

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

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

cmp - 用于比较数组元素的比较器

返回:

如果两个数组在指定范围内相等，则返回 true

抛出:

IllegalArgumentException - 如果 aFromIndex > aToIndex 或 bFromIndex > bToIndex

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

NullPointerException - 如果任一数组或比较器为 null

自版本:

9

fill

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

将指定的长整型值分配给指定长整型数组的每个元素。

参数:

a - 要填充的数组

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

fill

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

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

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

参数:

a - 要填充的数组

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

fill

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

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

参数:

a - 要填充的数组

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

toIndex - 要用指定值填充的最后一个元素的索引

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

抛出:

IllegalArgumentException - 如果 fromIndex > toIndex

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

fill

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

将指定的短整型值分配给指定短整型数组的每个元素。

参数:

a - 要填充的数组

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

fill

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

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

参数:

a - 要填充的数组

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

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

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

抛出:

IllegalArgumentException - 如果fromIndex > toIndex

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

fill

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

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

参数:

a - 要填充的数组

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

fill

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

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

参数:

a - 要填充的数组

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

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

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

抛出:

IllegalArgumentException - 如果fromIndex > toIndex

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

fill

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

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

参数:

a - 要填充的数组

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

fill

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

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

参数:

a - 要填充的数组

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

fill

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

将指定的boolean值分配给指定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)
            

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

参数:

a - 要填充的数组

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

fill

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

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

参数:

a - 要填充的数组

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

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

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

抛出:

IllegalArgumentException - 如果fromIndex > toIndex

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

fill

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

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

参数:

a - 要填充的数组

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

fill

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

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

参数:

a - 要填充的数组

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

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

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

抛出:

IllegalArgumentException - 如果fromIndex > toIndex

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

fill

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

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

参数:

a - 要填充的数组

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

抛出:

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

fill

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

将指定的Object引用分配给指定Object数组的指定范围内的每个元素。要填充的范围从索引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（如果必要），以使副本具有指定的长度。对于原始数组和副本中都有效的所有索引，两个数组将包含相同的值。对于副本中有效但原始数组中无效的任何索引，副本将包含null。只有当指定长度大于原始数组的长度时，这样的索引才会存在。生成的数组与原始数组的类完全相同。

类型参数:

T - 数组中对象的类

参数:

original - 要复制的数组

newLength - 要返回的复制品的长度

返回:

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

抛出:

NegativeArraySizeException - 如果newLength为负

NullPointerException - 如果original为null

自1.6版本起:

1.6

copyOf

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

复制指定的数组，截断或填充为null（如果需要），使复制品具有指定的长度。对于原始数组和复制品中都有效的所有索引，两个数组将包含相同的值。对于复制品中有效但原始数组中无效的任何索引，复制品将包含null。只有在指定长度大于原始数组长度时，这样的索引才会存在。结果数组是类newType的数组。

类型参数:

T - 返回的数组中对象的类

U - 原始数组中对象的类

参数:

original - 要复制的数组

newLength - 要返回的复制品的长度

newType - 要返回的复制品的类

返回:

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

抛出:

NegativeArraySizeException - 如果newLength为负

NullPointerException - 如果original为null

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

自1.6版本起:

1.6

copyOf

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

复制指定的数组，截断或填充为零（如果需要），使复制品具有指定的长度。对于原始数组和复制品中都有效的所有索引，两个数组将包含相同的值。对于复制品中有效但原始数组中无效的任何索引，复制品将包含(byte)0。只有在指定长度大于原始数组长度时，这样的索引才会存在。

参数:

original - 要复制的数组

newLength - 要返回的复制品的长度

返回:

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

抛出:

NegativeArraySizeException - 如果newLength为负

NullPointerException - 如果original为null

自1.6版本起:

1.6

copyOf

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

复制指定的数组，截断或填充为零（如果需要），使复制品具有指定的长度。对于原始数组和复制品中都有效的所有索引，两个数组将包含相同的值。对于复制品中有效但原始数组中无效的任何索引，复制品将包含(short)0。只有在指定长度大于原始数组长度时，这样的索引才会存在。

参数:

original - 要复制的数组

newLength - 要返回的复制品的长度

返回:

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

抛出:

NegativeArraySizeException - 如果newLength为负

NullPointerException - 如果original为null

自1.6版本起:

1.6

copyOf

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

复制指定的数组，截断或填充为零（如果需要），使复制品具有指定的长度。对于原始数组和复制品中都有效的所有索引，两个数组将包含相同的值。对于复制品中有效但原始数组中无效的任何索引，复制品将包含0。只有在指定长度大于原始数组长度时，这样的索引才会存在。

参数:

original - 要复制的数组

newLength - 要返回的复制品的长度

返回:

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

抛出:

NegativeArraySizeException - 如果newLength为负

NullPointerException - 如果original为null

自1.6版本起:

1.6

copyOf

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

复制指定的数组，截断或填充为零（如果需要），使复制品具有指定的长度。对于原始数组和复制品中都有效的所有索引，两个数组将包含相同的值。对于复制品中有效但原始数组中无效的任何索引，复制品将包含0L。只有在指定长度大于原始数组长度时，这样的索引才会存在。

参数:

original - 要复制的数组

newLength - 要返回的复制品的长度

返回:

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

抛出:

NegativeArraySizeException - 如果newLength为负

NullPointerException - 如果original为null

自1.6版本起:

1.6

copyOf

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

复制指定的数组，截断或填充为null字符（如果需要），使复制品具有指定的长度。对于原始数组和复制品中都有效的所有索引，两个数组将包含相同的值。对于复制品中有效但原始数组中无效的任何索引，复制品将包含'\u0000'。只有在指定长度大于原始数组长度时，这样的索引才会存在。

参数:

original - 要复制的数组

newLength - 要返回的复制品的长度

返回:

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

抛出:

NegativeArraySizeException - 如果newLength为负

NullPointerException - 如果original为null

自1.6版本起:

1.6

copyOf

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

复制指定的数组，截断或填充为零（如果需要），使复制品具有指定的长度。对于原始数组和复制品中都有效的所有索引，两个数组将包含相同的值。对于复制品中有效但原始数组中无效的任何索引，复制品将包含0f。只有在指定长度大于原始数组长度时，这样的索引才会存在。

参数:

original - 要复制的数组

newLength - 要返回的复制品的长度

返回:

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

抛出:

NegativeArraySizeException - 如果newLength为负

NullPointerException - 如果original为null

自1.6版本起:

1.6

copyOf

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

复制指定的数组，截断或填充为零（如果需要），使复制品具有指定的长度。对于原始数组和复制品中都有效的所有索引，两个数组将包含相同的值。对于复制品中有效但原始数组中无效的任何索引，复制品将包含0d。只有在指定长度大于原始数组长度时，这样的索引才会存在。

参数:

original - 要复制的数组

newLength - 要返回的复制品的长度

返回:

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

抛出:

NegativeArraySizeException - 如果newLength为负

NullPointerException - 如果original为null

自1.6版本起:

1.6

copyOf

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

复制指定的数组，截断或填充为false（如果需要），使复制品具有指定的长度。对于原始数组和复制品中都有效的所有索引，两个数组将包含相同的值。对于复制品中有效但原始数组中无效的任何索引，复制品将包含false。只有在指定长度大于原始数组长度时，这样的索引才会存在。

参数:

original - 要复制的数组

newLength - 要返回的复制的长度

返回:

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

抛出:

NegativeArraySizeException - 如果newLength为负

NullPointerException - 如果original为null

自版本:

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，在这种情况下，将在副本中的所有索引大于或等于original.length - from的元素中放入null。返回的数组的长度将为to - from。

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

类型参数:

T - 数组中对象的类

参数:

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

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

to - 要复制的范围的最终索引，不包括（此索引可能超出数组范围）

返回:

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

抛出:

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

IllegalArgumentException - 如果from > to

NullPointerException - 如果original为null

自版本:

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，在这种情况下，将在副本中的所有索引大于或等于original.length - from的元素中放入null。返回的数组的长度将为to - from。结果数组是类newType的。

类型参数:

T - 返回数组中对象的类

U - 原始数组中对象的类

参数:

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

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

to - 要复制的范围的最终索引，不包括（此索引可能超出数组范围）

newType - 要返回的副本的类

返回:

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

抛出:

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

IllegalArgumentException - 如果from > to

NullPointerException - 如果original为null

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，在这种情况下，将在副本中的所有索引大于或等于original.length - from的元素中放入(byte)0。返回的数组的长度将为to - from。

参数:

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

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

to - 要复制的范围的最终索引，不包括（此索引可能超出数组范围）

返回:

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

抛出:

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

IllegalArgumentException - 如果from > to

NullPointerException - 如果original为null

自版本:

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，在这种情况下，将在副本中的所有索引大于或等于original.length - from的元素中放入(short)0。返回的数组的长度将为to - from。

参数:

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

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

to - 要复制的范围的最终索引，不包括（此索引可能超出数组范围）

返回:

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

抛出:

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

IllegalArgumentException - 如果from > to

NullPointerException - 如果original为null

自版本:

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，在这种情况下，将在副本中的所有索引大于或等于original.length - from的元素中放入0。返回的数组的长度将为to - from。

参数:

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

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

to - 要复制的范围的最终索引，不包括（此索引可能超出数组范围）

返回:

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

抛出:

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

IllegalArgumentException - 如果from > to

NullPointerException - 如果original为null

自版本:

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，在这种情况下，将在副本中索引大于或等于original.length - from的所有元素中放置0L。返回数组的长度将为to - from。

参数:

original - 要复制范围的数组

from - 要复制范围的初始索引（包括）

to - 要复制范围的最终索引（不包括）。（此索引可能超出数组范围。）

返回:

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

抛出:

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

IllegalArgumentException - 如果from > to

NullPointerException - 如果original为null

自版本:

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，在这种情况下，将在副本中索引大于或等于original.length - from的所有元素中放置'\u0000'。返回数组的长度将为to - from。

参数:

original - 要复制范围的数组

from - 要复制范围的初始索引（包括）

to - 要复制范围的最终索引（不包括）。（此索引可能超出数组范围。）

返回:

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

抛出:

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

IllegalArgumentException - 如果from > to

NullPointerException - 如果original为null

自版本:

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，在这种情况下，将在副本中索引大于或等于original.length - from的所有元素中放置0f。返回数组的长度将为to - from。

参数:

original - 要复制范围的数组

from - 要复制范围的初始索引（包括）

to - 要复制范围的最终索引（不包括）。（此索引可能超出数组范围。）

返回:

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

抛出:

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

IllegalArgumentException - 如果from > to

NullPointerException - 如果original为null

自版本:

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，在这种情况下，将在副本中索引大于或等于original.length - from的所有元素中放置0d。返回数组的长度将为to - from。

参数:

original - 要复制范围的数组

from - 要复制范围的初始索引（包括）

to - 要复制范围的最终索引（不包括）。（此索引可能超出数组范围。）

返回:

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

抛出:

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

IllegalArgumentException - 如果from > to

NullPointerException - 如果original为null

自版本:

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，在这种情况下，将在副本中索引大于或等于original.length - from的所有元素中放置false。返回数组的长度将为to - from。

参数:

original - 要复制范围的数组

from - 要复制范围的初始索引（包括）

to - 要复制范围的最终索引（不包括）。（此索引可能超出数组范围。）

返回:

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

抛出:

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

IllegalArgumentException - 如果from > to

NullPointerException - 如果original为null

自版本:

1.6

asList

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

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

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

如果指定数组的实际组件类型与类型参数T不同，这可能导致对返回列表的操作抛出ArrayStoreException。

API注释:

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

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

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

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

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

此方法返回的列表是可修改的。 要创建一个不可修改的列表，请使用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)。

此方法返回的值与在包含按照相同顺序表示a元素的Long实例的序列的hashCode方法上调用时获得的值相同。如果a为null，则此方法返回0。

参数:

a - 要计算哈希值的数组

返回:

a的基于内容的哈希码

自1.5版本起:

1.5

hashCode

             public static int hashCode(int[] a)
            

返回基于指定数组内容的哈希码。对于任意两个非空int数组a和b，使得Arrays.equals(a, b)，则Arrays.hashCode(a) == Arrays.hashCode(b)。

此方法返回的值与在包含按照相同顺序表示a元素的Integer实例的序列的hashCode方法上调用时获得的值相同。如果a为null，则此方法返回0。

参数:

a - 要计算哈希值的数组

返回:

a的基于内容的哈希码

自1.5版本起:

1.5

hashCode

             public static int hashCode(short[] a)
            

返回基于指定数组内容的哈希码。对于任意两个short数组a和b，使得Arrays.equals(a, b)，则Arrays.hashCode(a) == Arrays.hashCode(b)。

此方法返回的值与在包含按照相同顺序表示a元素的Short实例的序列的hashCode方法上调用时获得的值相同。如果a为null，则此方法返回0。

参数:

a - 要计算哈希值的数组

返回:

a的基于内容的哈希码

自1.5版本起:

1.5

hashCode

             public static int hashCode(char[] a)
            

返回基于指定数组内容的哈希码。对于任意两个char数组a和b，使得Arrays.equals(a, b)，则Arrays.hashCode(a) == Arrays.hashCode(b)。

此方法返回的值与在包含按照相同顺序表示a元素的Character实例的序列的hashCode方法上调用时获得的值相同。如果a为null，则此方法返回0。

参数:

a - 要计算哈希值的数组

返回:

a的基于内容的哈希码

自1.5版本起:

1.5

hashCode

             public static int hashCode(byte[] a)
            

返回基于指定数组内容的哈希码。对于任意两个byte数组a和b，使得Arrays.equals(a, b)，则Arrays.hashCode(a) == Arrays.hashCode(b)。

此方法返回的值与在包含按照相同顺序表示a元素的Byte实例的序列的hashCode方法上调用时获得的值相同。如果a为null，则此方法返回0。

参数:

a - 要计算哈希值的数组

返回:

a的基于内容的哈希码

自1.5版本起:

1.5

hashCode

             public static int hashCode(boolean[] a)
            

返回基于指定数组内容的哈希码。对于任意两个boolean数组a和b，使得Arrays.equals(a, b)，则Arrays.hashCode(a) == Arrays.hashCode(b)。

此方法返回的值与在包含按照相同顺序表示a元素的Boolean实例的序列的hashCode方法上调用时获得的值相同。如果a为null，则此方法返回0。

参数:

a - 要计算哈希值的数组

返回:

a的基于内容的哈希码

自1.5版本起:

1.5

hashCode

             public static int hashCode(float[] a)
            

返回基于指定数组内容的哈希码。对于任意两个float数组a和b，使得Arrays.equals(a, b)，则Arrays.hashCode(a) == Arrays.hashCode(b)。

此方法返回的值与在包含按照相同顺序表示a元素的Float实例的序列的hashCode方法上调用时获得的值相同。如果a为null，则此方法返回0。

参数:

a - 要计算哈希值的数组

返回:

a的基于内容的哈希码

自1.5版本起:

1.5

hashCode

             public static int hashCode(double[] a)
            

返回基于指定数组内容的哈希码。对于任意两个double数组a和b，使得Arrays.equals(a, b)，则Arrays.hashCode(a) == Arrays.hashCode(b)。

此方法返回的值与在包含按照相同顺序表示a元素的Double实例的序列的hashCode方法上调用时获得的值相同。如果a为null，则此方法返回0。

参数:

a - 要计算哈希值的数组

返回:

a的基于内容的哈希码

自1.5版本起:

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版本起:

1.5

参见:

• deepHashCode(Object[])

deepHashCode

             public static int deepHashCode(Object[] a)
            

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

对于任意两个数组a和b，使得Arrays.deepEquals(a, b)成立，也有Arrays.deepHashCode(a) == Arrays.deepHashCode(b)。

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

参数：

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

返回：

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

自：

1.5

参见：

• hashCode(Object[])

deepEquals

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

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

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

两个可能为null的元素e1和e2在以下任一条件成立时被认为是深度相等的：

• e1和e2都是对象引用类型的数组，并且Arrays.deepEquals(e1, e2)返回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 - 如果生成函数为null

自版本:

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 - 如果生成函数为null

自版本:

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 - 如果生成函数为null

自版本:

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 - 如果生成函数为null

自版本:

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 - 如果生成函数为null

自版本:

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 - 如果生成函数为null

自版本:

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 - 如果生成函数为null

自版本:

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 - 如果生成函数为null

自版本:

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或aToIndex > a.length或bFromIndex < 0或bToIndex > b.length

NullPointerException - 如果任一数组为null

自版本：

9

compare

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

Compares two byte arrays lexicographically.

If the two arrays share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Byte.compare(byte, byte), at an index within the respective arrays that is the prefix length. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two array lengths. (See mismatch(byte[], byte[]) for the definition of a common and proper prefix.)

A null array reference is considered lexicographically less than a non-null array reference. Two null array references are considered equal.

The comparison is consistent with equals, more specifically the following holds for arrays a and b:

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

API Note:

This method behaves as if (for non-null array references):

     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;
 

Parameters:

a - the first array to compare

b - the second array to compare

Returns:

the value 0 if the first and second array are equal and contain the same elements in the same order; a value less than 0 if the first array is lexicographically less than the second array; and a value greater than 0 if the first array is lexicographically greater than the second array

Since:

9

compare

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

Compares two byte arrays lexicographically over the specified ranges.

If the two arrays, over the specified ranges, share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Byte.compare(byte, byte), at a relative index within the respective arrays that is the length of the prefix. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two range lengths. (See mismatch(byte[], int, int, byte[], int, int) for the definition of a common and proper prefix.)

The comparison is consistent with equals, more specifically the following holds for arrays a and b with specified ranges [aFromIndex, aToIndex) and [bFromIndex, bToIndex) respectively:

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

API Note:

This method behaves as if:

     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);
 

Parameters:

a - the first array to compare

aFromIndex - the index (inclusive) of the first element in the first array to be compared

aToIndex - the index (exclusive) of the last element in the first array to be compared

b - the second array to compare

bFromIndex - the index (inclusive) of the first element in the second array to be compared

bToIndex - the index (exclusive) of the last element in the second array to be compared

Returns:

the value 0 if, over the specified ranges, the first and second array are equal and contain the same elements in the same order; a value less than 0 if, over the specified ranges, the first array is lexicographically less than the second array; and a value greater than 0 if, over the specified ranges, the first array is lexicographically greater than the second array

Throws:

IllegalArgumentException - if aFromIndex > aToIndex or if bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - if aFromIndex < 0 or aToIndex > a.length or if bFromIndex < 0 or bToIndex > b.length

NullPointerException - if either array is null

Since:

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或aToIndex > a.length或bFromIndex < 0或bToIndex > b.length

NullPointerException - 如果任一数组为null

自版本：

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一致，更具体地说，对于数组a和b，具有指定范围[aFromIndex, aToIndex)和[bFromIndex, bToIndex)的以下内容成立：

     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或aToIndex > a.length或bFromIndex < 0或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或aToIndex > a.length或bFromIndex < 0或bToIndex > b.length

NullPointerException - 如果任一数组为null

自版本:

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)
            

Compares two char arrays lexicographically over the specified ranges.

If the two arrays, over the specified ranges, share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Character.compare(char, char), at a relative index within the respective arrays that is the length of the prefix. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two range lengths. (See mismatch(char[], int, int, char[], int, int) for the definition of a common and proper prefix.)

The comparison is consistent with equals, more specifically the following holds for arrays a and b with specified ranges [aFromIndex, aToIndex) and [bFromIndex, bToIndex) respectively:

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

API Note:

This method behaves as if:

     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);
 

Parameters:

a - the first array to compare

aFromIndex - the index (inclusive) of the first element in the first array to be compared

aToIndex - the index (exclusive) of the last element in the first array to be compared

b - the second array to compare

bFromIndex - the index (inclusive) of the first element in the second array to be compared

bToIndex - the index (exclusive) of the last element in the second array to be compared

Returns:

the value 0 if, over the specified ranges, the first and second array are equal and contain the same elements in the same order; a value less than 0 if, over the specified ranges, the first array is lexicographically less than the second array; and a value greater than 0 if, over the specified ranges, the first array is lexicographically greater than the second array

Throws:

IllegalArgumentException - if aFromIndex > aToIndex or if bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - if aFromIndex < 0 or aToIndex > a.length or if bFromIndex < 0 or bToIndex > b.length

NullPointerException - if either array is null

Since:

9

compare

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

Compares two int arrays lexicographically.

If the two arrays share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Integer.compare(int, int), at an index within the respective arrays that is the prefix length. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two array lengths. (See mismatch(int[], int[]) for the definition of a common and proper prefix.)

A null array reference is considered lexicographically less than a non-null array reference. Two null array references are considered equal.

The comparison is consistent with equals, more specifically the following holds for arrays a and b:

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

API Note:

This method behaves as if (for non-null array references):

     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;
 

Parameters:

a - the first array to compare

b - the second array to compare

Returns:

the value 0 if the first and second array are equal and contain the same elements in the same order; a value less than 0 if the first array is lexicographically less than the second array; and a value greater than 0 if the first array is lexicographically greater than the second array

Since:

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或aToIndex > a.length或bFromIndex < 0或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或aToIndex > a.length或bFromIndex < 0或bToIndex > b.length

NullPointerException - 如果任一数组为null

自版本：

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或aToIndex > a.length或bFromIndex < 0或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或aToIndex > a.length或bFromIndex < 0或bToIndex > b.length

NullPointerException - 如果任一数组为null

自版本:

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或aToIndex > a.length或者bFromIndex < 0或bToIndex > b.length

NullPointerException - 如果任一数组为null

自Java版本:

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

自Java版本:

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或aToIndex > a.length或者bFromIndex < 0或bToIndex > b.length

NullPointerException - 如果任一数组为null

自Java版本:

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

自Java版本:

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或aToIndex > a.length或bFromIndex < 0或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或aToIndex > a.length或bFromIndex < 0或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或aToIndex > a.length或bFromIndex < 0或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或aToIndex > a.length或bFromIndex < 0或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或aToIndex > a.length或者bFromIndex < 0或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或aToIndex > a.length或者bFromIndex < 0或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或aToIndex > a.length或者bFromIndex < 0或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或aToIndex > a.length或者bFromIndex < 0或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或aToIndex > a.length或者bFromIndex < 0或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或aToIndex > a.length或者bFromIndex < 0或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或aToIndex > a.length或bFromIndex < 0或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或aToIndex > a.length或bFromIndex < 0或bToIndex > b.length

NullPointerException - 如果任一数组或比较器为null

自版本:

9