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