操纵 | 方法签名 | 描述 |
---|
排序 | sort(byte[] a) | 将指定数组按升序数值顺序排序。 |
sort(byte[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序排序。 |
sort(char[] a) | 将指定数组按升序数值顺序排序。 |
sort(char[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序排序。 |
sort(double[] a) | 将指定数组按升序数值顺序排序。 |
sort(double[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序排序。 |
sort(float[] a) | 将指定数组按升序数值顺序排序。 |
sort(float[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序排序。 |
sort(int[] a) | 将指定数组按升序数值顺序排序。 |
sort(int[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序排序。 |
sort(long[] a) | 将指定数组按升序数值顺序排序。 |
sort(long[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序排序。 |
sort(short[] a) | 将指定数组按升序数值顺序排序。 |
sort(short[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序排序。 |
sort(Object[] a) | 根据其元素的自然顺序,将指定对象数组按升序排序。 |
sort(Object[] a, int fromIndex, int toIndex) | 根据其元素的自然顺序,将指定数组的指定范围按升序排序。 |
sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) | 根据指定比较器的顺序,对指定数组的指定范围进行排序。 |
sort(T[] a, Comparator<? super T> c) | 根据指定比较器的顺序,对指定对象数组进行排序。 |
搜索 | binarySearch(byte[] a, byte key) | 使用二分搜索算法搜索指定字节数组中的指定值。 |
binarySearch(byte[] a, int fromIndex, int toIndex, byte key) | 使用二分搜索算法搜索指定字节数组的指定范围中的指定值。 |
binarySearch(char[] a, char key) | 使用二分搜索算法搜索指定字符数组中的指定值。 |
binarySearch(char[] a, int fromIndex, int toIndex, char key) | 使用二分搜索算法搜索指定字符数组的指定范围中的指定值。 |
binarySearch(double[] a, double key) | 使用二分搜索算法搜索指定双精度数组中的指定值。 |
binarySearch(double[] a, int fromIndex, int toIndex, double key) | 使用二分搜索算法搜索指定双精度数组的指定范围中的指定值。 |
binarySearch(float[] a, float key) | 使用二分搜索算法搜索指定浮点数数组中的指定值。 |
binarySearch(float[] a, int fromIndex, int toIndex, float key) | 使用二分搜索算法搜索指定浮点数数组的指定范围中的指定值。 |
binarySearch(int[] a, int key) | 使用二分搜索算法搜索指定整数数组中的指定值。 |
binarySearch(int[] a, int fromIndex, int toIndex, int key) | 使用二分搜索算法搜索指定整数数组的指定范围中的指定值。 |
binarySearch(long[] a, int fromIndex, int toIndex, long key) | 使用二分搜索算法搜索指定长整型数组的指定范围中的指定值。 |
binarySearch(long[] a, long key) | 使用二分搜索算法搜索指定长整型数组中的指定值。 |
binarySearch(short[] a, int fromIndex, int toIndex, short key) | 使用二分搜索算法搜索指定短整型数组的指定范围中的指定值。 |
binarySearch(short[] a, short key) | 使用二分搜索算法搜索指定短整型数组中的指定值。 |
binarySearch(Object[] a, int fromIndex, int toIndex, Object key) | 使用二分搜索算法搜索指定数组的指定范围中的指定对象。 |
binarySearch(Object[] a, Object key) | 使用二分搜索算法搜索指定数组中的指定对象。 |
binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c) | 使用二分搜索算法搜索指定数组的指定范围中的指定对象。 |
binarySearch(T[] a, T key, Comparator<? super T> c) | 使用二分搜索算法搜索指定数组中的指定对象。 |
比较 | deepEquals(Object[] a1, Object[] a2) | 当两个指定数组深度相等时返回 true。 |
deepHashCode(Object[] a) | 返回基于指定数组“深度内容”的哈希码。 |
deepToString(Object[] a) | 返回指定数组“深度内容”的字符串表示形式。 |
equals(boolean[] a, boolean[] a2) | 当两个指定的布尔数组相等时返回 true。 |
equals(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex) | 当两个指定的布尔数组在指定范围内相等时返回 true。 |
equals(byte[] a, byte[] a2) | 当两个指定的字节数组相等时返回 true。 |
equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex) | 当两个指定的字节数组在指定范围内相等时返回 true。 |
equals(char[] a, char[] a2) | 当两个指定的字符数组相等时返回 true。 |
equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex) | 当两个指定的字符数组在指定范围内相等时返回 true。 |
equals(double[] a, double[] a2) | 当两个指定的双精度数组相等时返回 true。 |
equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex) | 当两个指定的双精度数组在指定范围内相等时返回 true。 |
equals(float[] a, float[] a2) | 当两个指定的浮点数数组相等时返回 true。 |
equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex) | 当两个指定的浮点数数组在指定范围内相等时返回 true。 |
equals(int[] a, int[] a2) | 当两个指定的整数数组相等时返回 true。 |
equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) | 当两个指定的整数数组在指定范围内相等时返回 true。 |
equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex) | 当两个指定的长整型数组在指定范围内相等时返回 true。 |
equals(long[] a, long[] a2) | 当两个指定的长整型数组相等时返回 true。 |
equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex) | 当两个指定的短整型数组在指定范围内相等时返回 true。 |
equals(short[] a, short[] a2) | 当两个指定的短整型数组相等时返回 true。 |
equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex) | 当两个指定的对象数组在指定范围内相等时返回 true。 |
equals(Object[] a, Object[] a2) | 当两个指定的对象数组相等时返回 true。 |
equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) | 当两个指定的对象数组在指定范围内相等时返回 true。 |
equals(T[] a, T[] a2, Comparator<? super T> cmp) | 当两个指定的对象数组相等时返回 true。 |
compare(boolean[] a, boolean[] b) | 按字典序比较两个布尔数组。 |
compare(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个布尔数组。 |
compare(byte[] a, byte[] b) | 按字典序比较两个字节数组。 |
compare(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个字节数组。 |
compare(char[] a, char[] b) | 按字典序比较两个字符数组。 |
compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个字符数组。 |
compare(double[] a, double[] b) | 按字典序比较两个双精度数组。 |
compare(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个双精度数组。 |
compare(float[] a, float[] b) | 按字典序比较两个浮点数数组。 |
compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个浮点数数组。 |
compare(int[] a, int[] b) | 按字典序比较两个整数数组。 |
compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个整数数组。 |
compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个长整型数组。 |
compare(long[] a, long[] b) | 按字典序比较两个长整型数组。 |
compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个短整型数组。 |
compare(short[] a, short[] b) | 按字典序比较两个短整型数组。 |
compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个对象数组。 |
compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) | 在指定范围内按字典序比较两个对象数组。 |
compare(T[] a, T[] b) | 按字典序比较两个对象数组(在可比较的元素之间)。 |
compare(T[] a, T[] b, Comparator<? super T> cmp) | 使用指定的比较器按字典序比较两个对象数组。 |
compareUnsigned(byte[] a, byte[] b) | 按字典序比较两个字节数组,将元素视为无符号。 |
compareUnsigned(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个字节数组,将元素视为无符号。 |
compareUnsigned(int[] a, int[] b) | 按字典序比较两个整数数组,将元素视为无符号。 |
compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个整数数组,将元素视为无符号。 |
compareUnsigned(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个长整型数组,将元素视为无符号。 |
compareUnsigned(long[] a, long[] b) | 按字典序比较两个长整型数组,将元素视为无符号。 |
compareUnsigned(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典序比较两个短整型数组,将元素视为无符号。 |
compareUnsigned(short[] a, short[] b) | 按字典序比较两个短整型数组,将元素视为无符号。 |
复印 | copyOf(boolean[] original, int newLength) | 复制指定的数组,截断或用 false 填充(如果需要),以便副本具有指定的长度。 |
copyOf(byte[] original, int newLength) | 复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。 |
copyOf(char[] original, int newLength) | 复制指定的数组,截断或用空字符填充(如果需要),以便副本具有指定的长度。 |
copyOf(double[] original, int newLength) | 复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。 |
copyOf(float[] original, int newLength) | 复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。 |
copyOf(int[] original, int newLength) | 复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。 |
copyOf(long[] original, int newLength) | 复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。 |
copyOf(short[] original, int newLength) | 复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。 |
copyOf(T[] original, int newLength) | 复制指定的数组,截断或用 null 填充(如果需要),以便副本具有指定的长度。 |
copyOf(U[] original, int newLength, Class<? extends T[]> newType) | 复制指定的数组,截断或用 null 填充(如果需要),以便副本具有指定的长度。 |
copyOfRange(boolean[] original, int from, int to) | 将指定数组的指定范围复制到一个新数组中。 |
copyOfRange(byte[] original, int from, int to) | 将指定数组的指定范围复制到一个新数组中。 |
copyOfRange(char[] original, int from, int to) | 将指定数组的指定范围复制到一个新数组中。 |
copyOfRange(double[] original, int from, int to) | 将指定数组的指定范围复制到一个新数组中。 |
copyOfRange(float[] original, int from, int to) | 将指定数组的指定范围复制到一个新数组中。 |
copyOfRange(int[] original, int from, int to) | 将指定数组的指定范围复制到一个新数组中。 |
copyOfRange(long[] original, int from, int to) | 将指定数组的指定范围复制到一个新数组中。 |
copyOfRange(short[] original, int from, int to) | 将指定数组的指定范围复制到一个新数组中。 |
copyOfRange(T[] original, int from, int to) | 将指定数组的指定范围复制到一个新数组中。 |
copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) | 将指定数组的指定范围复制到一个新数组中。 |
填充 | fill(boolean[] a, boolean val) | 将指定的布尔值分配给指定布尔数组的每个元素。 |
fill(boolean[] a, int fromIndex, int toIndex, boolean val) | 将指定的布尔值分配给指定布尔数组的指定范围的每个元素。 |
fill(byte[] a, byte val) | 将指定的字节值分配给指定字节数组的每个元素。 |
fill(byte[] a, int fromIndex, int toIndex, byte val) | 将指定的字节值分配给指定字节数组的指定范围的每个元素。 |
fill(char[] a, char val) | 将指定的字符值分配给指定字符数组的每个元素。 |
fill(char[] a, int fromIndex, int toIndex, char val) | 将指定的字符值分配给指定字符数组的指定范围的每个元素。 |
fill(double[] a, double val) | 将指定的双精度值分配给指定双精度数组的每个元素。 |
fill(double[] a, int fromIndex, int toIndex, double val) | 将指定的双精度值分配给指定双精度数组的指定范围的每个元素。 |
fill(float[] a, float val) | 将指定的浮点数值分配给指定浮点数数组的每个元素。 |
fill(float[] a, int fromIndex, int toIndex, float val) | 将指定的浮点数值分配给指定浮点数数组的指定范围的每个元素。 |
fill(int[] a, int val) | 将指定的整数值分配给指定整数数组的每个元素。 |
fill(int[] a, int fromIndex, int toIndex, int val) | 将指定的整数值分配给指定整数数组的指定范围的每个元素。 |
fill(long[] a, int fromIndex, int toIndex, long val) | 将指定的长整型值分配给指定长整型数组的指定范围的每个元素。 |
fill(long[] a, long val) | 将指定的长整型值分配给指定长整型数组的每个元素。 |
fill(short[] a, int fromIndex, int toIndex, short val) | 将指定的短整型值分配给指定短整型数组的指定范围的每个元素。 |
fill(short[] a, short val) | 将指定的短整型值分配给指定短整型数组的每个元素。 |
fill(Object[] a, int fromIndex, int toIndex, Object val) | 将指定的 Object 引用分配给指定对象数组的指定范围的每个元素。 |
fill(Object[] a, Object val) | 将指定的 Object 引用分配给指定对象数组的每个元素。 |
Stream | stream(double[] array) | 返回一个以指定数组为源的顺序 DoubleStream。 |
stream(double[] array, int startInclusive, int endExclusive) | 返回一个以指定数组的指定范围为源的顺序 DoubleStream。 |
stream(int[] array) | 返回一个以指定数组为源的顺序 IntStream。 |
stream(int[] array, int startInclusive, int endExclusive) | 返回一个以指定数组的指定范围为源的顺序 IntStream。 |
stream(long[] array) | 返回一个以指定数组为源的顺序 LongStream。 |
stream(long[] array, int startInclusive, int endExclusive) | 返回一个以指定数组的指定范围为源的顺序 LongStream。 |
stream(T[] array) | 返回一个以指定数组为源的顺序 Stream。 |
stream(T[] array, int startInclusive, int endExclusive) | 返回一个以指定数组的指定范围为源的顺序 Stream。 |
转换 | toString(boolean[] a) | 返回指定数组内容的字符串表示形式。 |
toString(byte[] a) | 返回指定数组内容的字符串表示形式。 |
toString(char[] a) | 返回指定数组内容的字符串表示形式。 |
toString(double[] a) | 返回指定数组内容的字符串表示形式。 |
toString(float[] a) | 返回指定数组内容的字符串表示形式。 |
toString(int[] a) | 返回指定数组内容的字符串表示形式。 |
toString(long[] a) | 返回指定数组内容的字符串表示形式。 |
toString(short[] a) | 返回指定数组内容的字符串表示形式。 |
toString(Object[] a) | 返回指定数组内容的字符串表示形式。 |
| asList(T... a) | 返回一个由指定数组支持的固定大小的列表。 |
用途 | hashCode(boolean[] a) | 返回基于指定数组内容的哈希码。 |
hashCode(byte[] a) | 返回基于指定数组内容的哈希码。 |
hashCode(char[] a) | 返回基于指定数组内容的哈希码。 |
hashCode(double[] a) | 返回基于指定数组内容的哈希码。 |
hashCode(float[] a) | 返回基于指定数组内容的哈希码。 |
hashCode(int[] a) | 返回基于指定数组内容的哈希码。 |
hashCode(long[] a) | 返回基于指定数组内容的哈希码。 |
hashCode(short[] a) | 返回基于指定数组内容的哈希码。 |
hashCode(Object[] a) | 返回基于指定数组内容的哈希码。 |
mismatch(boolean[] a, boolean[] b) | 查找并返回两个布尔数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex) | 在指定范围内查找并返回两个布尔数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。 |
mismatch(byte[] a, byte[] b) | 查找并返回两个字节数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex) | 在指定范围内查找并返回两个字节数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。 |
mismatch(char[] a, char[] b) | 查找并返回两个字符数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex) | 在指定范围内查找并返回两个字符数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。 |
mismatch(double[] a, double[] b) | 查找并返回两个双精度数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex) | 在指定范围内查找并返回两个双精度数组之间第一个不匹配项的相对索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(float[] a, float[] b) | 查找并返回两个浮点数数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex) | 在指定范围内查找并返回两个浮点数数组之间第一个不匹配项的相对索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(int[] a, int[] b) | 查找并返回两个整数数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) | 在指定范围内查找并返回两个整数数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。 |
mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex) | 在指定范围内查找并返回两个长整型数组之间第一个不匹配项的相对索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(long[] a, long[] b) | 查找并返回两个长整型数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex) | 在指定范围内查找并返回两个短整型数组之间第一个不匹配项的相对索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(short[] a, short[] b) | 查找并返回两个短整型数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex) | 在指定范围内查找并返回两个对象数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。 |
mismatch(Object[] a, Object[] b) | 查找并返回两个对象数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。 |
mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) | 在指定范围内查找并返回两个对象数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。 |
mismatch(T[] a, T[] b, Comparator<? super T> cmp) | 查找并返回两个对象数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。 |
并行数组 | parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op) | 对给定数组的子范围执行 parallelPrefix(double[], DoubleBinaryOperator)。 |
parallelPrefix(double[] array, DoubleBinaryOperator op) | 使用提供的函数,并行地累加给定数组的每个元素(就地)。 |
parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op) | 对给定数组的子范围执行 parallelPrefix(int[], IntBinaryOperator)。 |
parallelPrefix(int[] array, IntBinaryOperator op) | 使用提供的函数,并行地累加给定数组的每个元素(就地)。 |
parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op) | 对给定数组的子范围执行 parallelPrefix(long[], LongBinaryOperator)。 |
parallelPrefix(long[] array, LongBinaryOperator op) | 使用提供的函数,并行地累加给定数组的每个元素(就地)。 |
parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op) | 对给定数组的子范围执行 parallelPrefix(Object[], BinaryOperator)。 |
parallelPrefix(T[] array, BinaryOperator<T> op) | 使用提供的函数,并行地累加给定数组的每个元素(就地)。 |
parallelSetAll(double[] array, IntToDoubleFunction generator) | 使用提供的生成器函数计算每个元素,并行设置指定数组的所有元素。 |
parallelSetAll(int[] array, IntUnaryOperator generator) | 使用提供的生成器函数计算每个元素,并行设置指定数组的所有元素。 |
parallelSetAll(long[] array, IntToLongFunction generator) | 使用提供的生成器函数计算每个元素,并行设置指定数组的所有元素。 |
parallelSetAll(T[] array, IntFunction<? extends T> generator) | 使用提供的生成器函数计算每个元素,并行设置指定数组的所有元素。 |
parallelSort(byte[] a) | 将指定数组按升序数值顺序排序。 |
parallelSort(byte[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序数值顺序排序。 |
parallelSort(char[] a) | 将指定数组按升序数值顺序排序。 |
parallelSort(char[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序数值顺序排序。 |
parallelSort(double[] a) | 将指定数组按升序数值顺序排序。 |
parallelSort(double[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序数值顺序排序。 |
parallelSort(float[] a) | 将指定数组按升序数值顺序排序。 |
parallelSort(float[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序数值顺序排序。 |
parallelSort(int[] a) | 将指定数组按升序数值顺序排序。 |
parallelSort(int[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序数值顺序排序。 |
parallelSort(long[] a) | 将指定数组按升序数值顺序排序。 |
parallelSort(long[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序数值顺序排序。 |
parallelSort(short[] a) | 将指定数组按升序数值顺序排序。 |
parallelSort(short[] a, int fromIndex, int toIndex) | 将指定范围的数组按升序数值顺序排序。 |
parallelSort(T[] a) | 根据其元素的自然顺序,将指定对象数组按升序排序。 |
parallelSort(T[] a, int fromIndex, int toIndex) | 根据其元素的自然顺序,将指定数组的指定范围按升序排序。 |
parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp) | 根据指定比较器的顺序,对指定数组的指定范围进行排序。 |
parallelSort(T[] a, Comparator<? super T> cmp) | 根据指定比较器的顺序,对指定对象数组进行排序。 |
Set | setAll(double[] array, IntToDoubleFunction generator) | 使用提供的生成器函数计算每个元素,设置指定数组的所有元素。 |
setAll(int[] array, IntUnaryOperator generator) | 使用提供的生成器函数计算每个元素,设置指定数组的所有元素。 |
setAll(long[] array, IntToLongFunction generator) | 使用提供的生成器函数计算每个元素,设置指定数组的所有元素。 |
setAll(T[] array, IntFunction<? extends T> generator) | 使用提供的生成器函数计算每个元素,设置指定数组的所有元素。 |