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