public class Arrays extends Object
如果指定的数组引用为空,则该类中的方法都抛出一个NullPointerException
,除非另有说明。
该类中包含的方法的文档包括实现的简要描述 。 这些描述应被视为实施说明 ,而不是说明书的一部分 。 只要规范本身得到遵守,实现者就可以随意替代其他算法。 (例如,sort(Object[])使用的sort(Object[])
不一定是MergeSort,但它必须是稳定的 。)
这个班是Java Collections Framework的成员。
Modifier and Type | Method and Description |
---|---|
static <T> List<T> |
asList(T... a)
返回由指定数组支持的固定大小的列表。
|
static int |
binarySearch(byte[] a, byte key)
使用二进制搜索算法搜索指定值的指定字节数组。
|
static int |
binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
使用二进制搜索算法搜索指定值的指定字节数组的范围。
|
static int |
binarySearch(char[] a, char key)
使用二进制搜索算法搜索指定数组的指定值。
|
static int |
binarySearch(char[] a, int fromIndex, int toIndex, char key)
使用二分搜索算法搜索指定值的指定数组的范围。
|
static int |
binarySearch(double[] a, double key)
使用二进制搜索算法搜索指定值的指定数组的双精度值。
|
static int |
binarySearch(double[] a, int fromIndex, int toIndex, double key)
使用二分搜索算法搜索指定值的指定数组的双精度范围。
|
static int |
binarySearch(float[] a, float key)
使用二叉搜索算法搜索指定数组的浮点数。
|
static int |
binarySearch(float[] a, int fromIndex, int toIndex, float key)
使用二分搜索算法搜索指定数组的浮点数范围。
|
static int |
binarySearch(int[] a, int key)
使用二叉搜索算法搜索指定的int数组的指定值。
|
static int |
binarySearch(int[] a, int fromIndex, int toIndex, int key)
使用二叉搜索算法搜索指定值的指定数组的范围。
|
static int |
binarySearch(long[] a, int fromIndex, int toIndex, long key)
使用二分搜索算法搜索指定值的指定数组的范围。
|
static int |
binarySearch(long[] a, long key)
使用二进制搜索算法搜索指定数组的指定数组。
|
static int |
binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
使用二进制搜索算法搜索指定对象的指定数组的范围。
|
static int |
binarySearch(Object[] a, Object key)
使用二叉搜索算法搜索指定对象的指定数组。
|
static int |
binarySearch(short[] a, int fromIndex, int toIndex, short key)
使用二进制搜索算法搜索指定值的指定数组的短整型范围。
|
static int |
binarySearch(short[] a, short 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 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(byte[] a, byte[] a2)
如果两个指定的字节数组彼此
相等 ,则返回
true 。
|
static boolean |
equals(char[] a, char[] a2)
如果两个指定的字符数组彼此
相等 ,则返回
true 。
|
static boolean |
equals(double[] a, double[] a2)
如果两个指定的双精度数组彼此
相等 ,则返回
true 。
|
static boolean |
equals(float[] a, float[] a2)
如果两个指定的浮动数组彼此
相等 ,则返回
true 。
|
static boolean |
equals(int[] a, int[] a2)
如果两个指定的int数组彼此
相等 ,则返回
true 。
|
static boolean |
equals(long[] a, long[] a2)
如果两个指定的longs数组彼此
相等 ,则返回
true 。
|
static boolean |
equals(Object[] a, Object[] a2)
如果两个指定的对象数组彼此
相等 ,则返回
true 。
|
static boolean |
equals(short[] a, short[] a2)
如果两个指定的短裤阵列彼此
相等 ,则返回
true 。
|
static void |
fill(boolean[] a, boolean val)
将指定的布尔值分配给指定的布尔数组的每个元素。
|
static void |
fill(boolean[] a, int fromIndex, int toIndex, boolean val)
将指定的布尔值分配给指定数组布尔值的指定范围的每个元素。
|
static void |
fill(byte[] a, byte val)
将指定的字节值分配给指定字节数组的每个元素。
|
static void |
fill(byte[] a, int fromIndex, int toIndex, byte val)
将指定的字节值分配给指定字节数组的指定范围的每个元素。
|
static void |
fill(char[] a, char val)
将指定的char值分配给指定的char数组的每个元素。
|
static void |
fill(char[] a, int fromIndex, int toIndex, char val)
将指定的char值分配给指定的char数组的指定范围的每个元素。
|
static void |
fill(double[] a, double val)
将指定的double值分配给指定的双精度数组的每个元素。
|
static void |
fill(double[] a, int fromIndex, int toIndex, double val)
将指定的double值分配给指定的双精度数组范围的每个元素。
|
static void |
fill(float[] a, float val)
将指定的float值分配给指定的浮点数组的每个元素。
|
static void |
fill(float[] a, int fromIndex, int toIndex, float val)
将指定的浮点值分配给指定的浮点数组的指定范围的每个元素。
|
static void |
fill(int[] a, int val)
将指定的int值分配给指定的int数组的每个元素。
|
static void |
fill(int[] a, int fromIndex, int toIndex, int val)
将指定的int值分配给指定的int数组的指定范围的每个元素。
|
static void |
fill(long[] a, int fromIndex, int toIndex, long val)
将指定的long值分配给指定的longs数组的指定范围的每个元素。
|
static void |
fill(long[] a, long val)
将指定的long值分配给指定的longs数组的每个元素。
|
static void |
fill(Object[] a, int fromIndex, int toIndex, Object val)
将指定的对象引用分配给指定的对象数组的指定范围的每个元素。
|
static void |
fill(Object[] a, Object val)
将指定的对象引用分配给指定的对象数组的每个元素。
|
static void |
fill(short[] a, int fromIndex, int toIndex, short val)
将指定的短值分配给指定的短裤数组的指定范围的每个元素。
|
static void |
fill(short[] a, short val)
将指定的短值分配给指定的短裤数组的每个元素。
|
static int |
hashCode(boolean[] a)
根据指定数组的内容返回哈希码。
|
static int |
hashCode(byte[] a)
根据指定数组的内容返回哈希码。
|
static int |
hashCode(char[] a)
根据指定数组的内容返回哈希码。
|
static int |
hashCode(double[] a)
根据指定数组的内容返回哈希码。
|
static int |
hashCode(float[] a)
根据指定数组的内容返回哈希码。
|
static int |
hashCode(int[] a)
根据指定数组的内容返回哈希码。
|
static int |
hashCode(long[] a)
根据指定数组的内容返回哈希码。
|
static int |
hashCode(Object[] a)
根据指定数组的内容返回哈希码。
|
static int |
hashCode(short[] a)
根据指定数组的内容返回哈希码。
|
static void |
parallelPrefix(double[] array, DoubleBinaryOperator op)
使用提供的功能,并行地计算给定阵列的每个元素。
|
static void |
parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)
对于数组的给定子范围执行
parallelPrefix(double[], DoubleBinaryOperator) 。
|
static void |
parallelPrefix(int[] array, IntBinaryOperator op)
使用提供的功能,并行地计算给定阵列的每个元素。
|
static void |
parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)
对于数组的给定子范围执行
parallelPrefix(int[], IntBinaryOperator) 。
|
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, BinaryOperator<T> op)
使用提供的功能,并行地计算给定阵列的每个元素。
|
static <T> void |
parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)
对于数组的给定子范围执行
parallelPrefix(Object[], BinaryOperator) 。
|
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>> |
parallelSort(T[] a)
对指定对象升序排列的阵列,根据natural ordering的元素。
|
static <T> void |
parallelSort(T[] a, Comparator<? super T> cmp)
根据指定的比较器引发的顺序对指定的对象数组进行排序。
|
static <T extends Comparable<? super T>> |
parallelSort(T[] a, int fromIndex, int toIndex)
对指定对象升序排列的数组的指定范围内,根据natural ordering的元素。
|
static <T> void |
parallelSort(T[] a, int fromIndex, int toIndex, 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(Object[] a)
对指定对象升序排列的阵列,根据natural ordering的元素。
|
static void |
sort(Object[] a, int fromIndex, int toIndex)
对指定对象升序排列的数组的指定范围内,根据natural ordering的元素。
|
static void |
sort(short[] a)
按照数字顺序排列指定的数组。
|
static void |
sort(short[] a, int fromIndex, int toIndex)
按升序排列数组的指定范围。
|
static <T> void |
sort(T[] a, Comparator<? super T> c)
根据指定的比较器引发的顺序对指定的对象数组进行排序。
|
static <T> void |
sort(T[] a, int fromIndex, int toIndex, 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(Object[] a)
返回指定数组的内容的字符串表示形式。
|
static String |
toString(short[] a)
返回指定数组的内容的字符串表示形式。
|
public static void sort(int[] a)
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的数组
public static void sort(int[] a, int fromIndex, int toIndex)
fromIndex
(包括)扩展到索引toIndex
,排他。
如果fromIndex == toIndex
,要排序的范围是空的。
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(
fromIndex
)的索引
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
public static void sort(long[] a)
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的数组
public static void sort(long[] a, int fromIndex, int toIndex)
fromIndex
(包括)扩展到索引toIndex
,排他。
如果fromIndex == toIndex
,要排序的范围是空的。
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(
fromIndex
)的索引
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果是
fromIndex < 0
或
toIndex > a.length
public static void sort(short[] a)
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的数组
public static void sort(short[] a, int fromIndex, int toIndex)
fromIndex
,包容,到索引toIndex
,排斥。
如果fromIndex == toIndex
,要排序的范围是空的。
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的阵列
fromIndex
- 要排序的第一个元素的索引(包括)
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果是
fromIndex < 0
或
toIndex > a.length
public static void sort(char[] a)
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的数组
public static void sort(char[] a, int fromIndex, int toIndex)
fromIndex
(包括)扩展到索引toIndex
,排他。
如果fromIndex == toIndex
,要排序的范围是空的。
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(
fromIndex
)的索引
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果是
fromIndex < 0
或
toIndex > a.length
public static void sort(byte[] a)
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的数组
public static void sort(byte[] a, int fromIndex, int toIndex)
fromIndex
(包括)扩展到索引toIndex
,排他。
如果fromIndex == toIndex
,要排序的范围是空的。
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素的索引(包括)
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
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
- 要排序的数组
public static void sort(float[] a, int fromIndex, int toIndex)
fromIndex
(包括)扩展到索引toIndex
,排他。
如果fromIndex == toIndex
,要排序的范围是空的。
所述<
关系不能在所有浮点值提供一个总次序: -0.0f == 0.0f
是true
和Float.NaN
值进行比较既不小于,大于,也不等于任何值,甚至本身。 该方法使用方法Float.compareTo(java.lang.Float)
: -0.0f
处理的总订单被视为小于值0.0f
和Float.NaN
被认为大于任何其他值,并且所有Float.NaN
值被认为是相等的。
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(
fromIndex
)的索引
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
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
- 要排序的数组
public static void sort(double[] a, int fromIndex, int toIndex)
fromIndex
(包括)扩展到索引toIndex
,排他。
如果fromIndex == toIndex
,要排序的范围为空。
<
关系不能提供所有双重值的总订单: -0.0d == 0.0d
为true
,而Double.NaN
值既不小于,大于也不等于任何值,甚至本身。 此方法使用方法Double.compareTo(java.lang.Double)
: -0.0d
处理的总订单被视为小于值0.0d
和Double.NaN
认为大于任何其他值,并且所有Double.NaN
值被视为相等。
实施注意事项:排序算法是由Vladimir Yaroslavskiy,Jon Bentley和Joshua Bloch提供的双轴快速排序。 该算法在许多数据集上提供O(n log(n))性能,导致其他快速排序降级为二次性能,并且通常比传统(单轴)Quicksort实现更快。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(
fromIndex
)的索引
toIndex
- 要排序的最后一个元素的索引,排他
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
public static void parallelSort(byte[] a)
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法排序。
该算法需要一个不大于原始数组大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
public static void parallelSort(byte[] a, int fromIndex, int toIndex)
fromIndex
(包括)扩展到索引toIndex
,排他。
如果fromIndex == toIndex
,要排序的范围是空的。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要不大于原始数组的指定范围的大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素的索引(包括)
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
public static void parallelSort(char[] a)
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要一个不大于原始数组大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
public static void parallelSort(char[] a, int fromIndex, int toIndex)
fromIndex
,包容,到索引toIndex
,排斥。
如果fromIndex == toIndex
,要排序的范围是空的。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要不大于原始数组的指定范围的大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素的索引(包括)
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果是
fromIndex < 0
或
toIndex > a.length
public static void parallelSort(short[] a)
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要一个不大于原始数组大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
public static void parallelSort(short[] a, int fromIndex, int toIndex)
fromIndex
扩展到索引toIndex
,排他。
如果fromIndex == toIndex
,要排序的范围是空的。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要不大于原始数组的指定范围的大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素的索引(包括)
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
public static void parallelSort(int[] a)
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要一个不大于原始数组大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
public static void parallelSort(int[] a, int fromIndex, int toIndex)
fromIndex
,包容,到索引toIndex
,排斥。
如果fromIndex == toIndex
,要排序的范围为空。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要不大于原始数组的指定范围的大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(
fromIndex
)的索引
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
public static void parallelSort(long[] a)
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要一个不大于原始数组大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
public static void parallelSort(long[] a, int fromIndex, int toIndex)
fromIndex
,包容,到索引toIndex
,排斥。
如果fromIndex == toIndex
,要排序的范围是空的。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要不大于原始数组的指定范围的大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(
fromIndex
)的索引
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果是
fromIndex < 0
或
toIndex > a.length
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
值被认为是相等的。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要一个不大于原始数组大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
public static void parallelSort(float[] a, int fromIndex, int toIndex)
fromIndex
,包容,到索引toIndex
,排斥。
如果fromIndex == toIndex
,要排序的范围是空的。
所述<
关系不能在所有浮点值提供一个总次序: -0.0f == 0.0f
是true
和Float.NaN
值进行比较既不小于,大于,也不等于任何值,甚至本身。 该方法使用Float.compareTo(java.lang.Float)
: Float.compareTo(java.lang.Float)
: -0.0f
处理为小于值0.0f
和Float.NaN
的总顺序被认为大于任何其他值,并且所有Float.NaN
值都被视为相等。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要不大于原始数组的指定范围的大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(
fromIndex
)的索引
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
public static void parallelSort(double[] a)
所述<
关系不能在所有的双精度值提供一个总次序: -0.0d == 0.0d
是true
和Double.NaN
值进行比较既不小于,大于,也不等于任何值,甚至本身。 该方法使用方法Double.compareTo(java.lang.Double)
: -0.0d
处理的总顺序被视为小于值0.0d
,并且Double.NaN
被认为大于任何其他值,并且所有Double.NaN
值被认为相等。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要一个不大于原始数组大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
public static void parallelSort(double[] a, int fromIndex, int toIndex)
fromIndex
(包括)扩展到索引toIndex
,排他。
如果fromIndex == toIndex
,要排序的范围是空的。
<
关系不会提供所有双重值的总订单: -0.0d == 0.0d
为true
,而Double.NaN
值既不小于,大于也不等于任何值,甚至本身。 该方法使用方法Double.compareTo(java.lang.Double)
: -0.0d
处理的总顺序被视为小于值0.0d
,并且Double.NaN
被认为大于任何其他值,并且所有Double.NaN
值被认为是相等的。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要不大于原始数组的指定范围的大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素的索引(包括)
toIndex
- 最后一个要排序的元素的索引
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
public static <T extends Comparable<? super T>> void parallelSort(T[] a)
Comparable
接口。
此外,数组中的所有元素都必须相互可比较 (即, e1.compareTo(e2)
不能为ClassCastException
中的任何元素e1
和e2
)。
这种保证是稳定的 :等同的元素将不会被排序作为排序的结果。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要一个不大于原始数组大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
T
- 要排序的对象的类
a
- 要排序的数组
ClassCastException
- 如果数组包含不
相互比较的元素 (例如,字符串和整数)
IllegalArgumentException
- (可选)如果发现数组元素的自然排序违反了Comparable
合同
public static <T extends Comparable<? super T>> void parallelSort(T[] a, int fromIndex, int toIndex)
fromIndex
扩展到索引toIndex
,排他。
(如果fromIndex==toIndex
,要排序的范围为空。)此范围中的所有元素必须实现Comparable
接口。
此外,该范围内的所有元素必须相互可比较 (即, e1.compareTo(e2)
不得为ClassCastException
中的任何元素e1
和e2
)。
这种保证是稳定的 :等同的元素将不会被排序作为排序的结果。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要不大于原始数组的指定范围的大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
T
- 要排序的对象的类
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(包括)的索引
toIndex
- 要排序的最后一个元素(排他)的索引
IllegalArgumentException
- 如果fromIndex > toIndex
或(可选)如果发现数组元素的自然排序违反了Comparable
合同
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
ClassCastException
- 如果数组包含不
相互比较的元素 (例如,字符串和整数)。
public static <T> void parallelSort(T[] a, Comparator<? super T> cmp)
c.compare(e1, e2)
不能为ClassCastException
中的任何元素e1
和e2
)。
这种保证是稳定的 :等同的元素将不会被排序作为排序的结果。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要一个不大于原始数组大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
T
- 要排序的对象的类
a
- 要排序的数组
cmp
- 比较器来确定数组的顺序。
A null
值表示应使用元素' natural ordering '。
ClassCastException
- 如果数组包含使用指定的比较器不
相互比较的元素
IllegalArgumentException
- (可选)如果比较方发现违反Comparator
合同
public static <T> void parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)
fromIndex
扩展到索引toIndex
,排他。
(如果fromIndex==toIndex
,则排序范围为空。)范围内的所有元素都必须是指定比较相互比较的 (即, c.compare(e1, e2)
不得抛出ClassCastException
任何元件e1
和e2
中的范围内)。
这种保证是稳定的 :等同的元素将不会被排序作为排序的结果。
Arrays.sort
方法对子阵列进行排序。
如果指定数组的长度小于最小粒度,则使用适当的Arrays.sort
方法进行排序。
该算法需要不大于原始数组的指定范围的大小的工作空间。
ForkJoin common pool
用于执行任何并行任务。
T
- 要排序的对象的类
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(包括)的索引
toIndex
- 要排序的最后一个元素(排他)的索引
cmp
- 比较器来确定数组的顺序。
A null
值表示应使用元素' natural ordering '。
IllegalArgumentException
- 如果fromIndex > toIndex
或(可选)如果发现数组元素的自然排序违反了Comparable
合同
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
ClassCastException
- 如果数组包含不
相互比较的元素 (例如,字符串和整数)。
public static void sort(Object[] a)
Comparable
接口。
此外,数组中的所有元素必须相互可比较 (即, e1.compareTo(e2)
不能为ClassCastException
中的任何元素e1
和e2
)。
这种保证是稳定的 :等同的元素将不会被排序作为排序的结果。
实现注意事项:这个实现是一个稳定的,自适应的,迭代的mergeesort,当输入数组被部分排序时,需要比n lg(n)的比较少得多,同时在输入数组被随机排列时提供传统的mergeesort的性能。 如果输入数组几乎被排序,则实现需要大致n个比较。 临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的n / 2对象引用。
该实现在其输入数组中具有上升和下降的同等优势,并且可以在同一输入数组的不同部分中利用升序和降序。 它非常适合合并两个或多个排序的数组:简单地连接数组并排序生成的数组。
该实现根据Tim Peters的Python列表( TimSort )进行了改编 。 它使用Peter McIlroy的“乐观排序和信息理论复杂性”中的技术,在第四届ACM-SIAM离散算法研讨会论文集,pp 467-474,1993年1月。
a
- 要排序的数组
ClassCastException
- 如果数组包含不
相互比较的元素 (例如,字符串和整数)
IllegalArgumentException
- (可选)如果发现数组元素的自然排序违反了Comparable
合同
public static void sort(Object[] a, int fromIndex, int toIndex)
fromIndex
(包括)扩展到索引toIndex
,排他。
(如果fromIndex==toIndex
,要排序的范围为空。)此范围中的所有元素必须实现Comparable
接口。
此外,该范围内的所有元素必须相互可比较 (即, e1.compareTo(e2)
不能为ClassCastException
中的任何元素e1
和e2
)。
这种保证是稳定的 :等同的元素将不会被排序作为排序的结果。
实现注意事项:这个实现是一个稳定的,自适应的,迭代的mergeesort,当输入数组被部分排序时,需要比n lg(n)的比较少得多,同时在输入数组被随机排列时提供传统的mergeesort的性能。 如果输入数组几乎被排序,则实现需要大致n个比较。 临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的n / 2对象引用。
该实现在其输入数组中具有上升和下降的同等优势,并且可以在同一输入数组的不同部分中利用升序和降序。 它非常适合合并两个或多个排序的数组:简单地连接数组并排序生成的数组。
实施从Tim Peters的Python列表( TimSort )进行了改编 。 它使用Peter McIlroy的“乐观排序和信息理论复杂性”中的技术,在第四届ACM-SIAM离散算法研讨会论文集,pp 467-474,1993年1月。
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(包括)的索引
toIndex
- 要排序的最后一个元素(排他)的索引
IllegalArgumentException
- 如果fromIndex > toIndex
或(可选)如果发现数组元素的自然排序违反了Comparable
合同
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
ClassCastException
- 如果数组包含不
相互比较的元素 (例如,字符串和整数)。
public static <T> void sort(T[] a, Comparator<? super T> c)
c.compare(e1, e2)
不能为ClassCastException
中的任何元素e1
和e2
)。
这种保证是稳定的 :等同的元素将不会被排序作为排序的结果。
实现注意事项:这个实现是一个稳定的,自适应的,迭代的mergeesort,当输入数组被部分排序时,需要比n lg(n)的比较少得多,同时在输入数组被随机排列时提供传统的mergeesort的性能。 如果输入数组几乎被排序,则实现需要大致n个比较。 临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的n / 2对象引用。
该实现在其输入数组中具有上升和下降的同等优势,并且可以在同一输入数组的不同部分中利用升序和降序。 它非常适合合并两个或多个排序的数组:简单地连接数组并排序生成的数组。
该实现是从Tim Peters的Python列表( TimSort )中进行的。 它使用Peter McIlroy的“乐观排序和信息理论复杂性”中的技术,在第四届ACM-SIAM离散算法研讨会论文集,pp 467-474,1993年1月。
T
- 要排序的对象的类
a
- 要排序的数组
c
- 比较器确定阵列的顺序。
A null
值表示应使用元素' natural ordering '。
ClassCastException
- 如果数组包含使用指定比较器不
相互比较的元素
IllegalArgumentException
- (可选)如果比较方发现违反Comparator
合同
public static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
fromIndex
(包括)扩展到索引toIndex
,排他。
(如果fromIndex==toIndex
,则排序范围为空。)范围内的所有元素都必须是指定比较相互比较的 (即, c.compare(e1, e2)
不得抛出ClassCastException
任何元件e1
和e2
中的范围内)。
这种保证是稳定的 :等同的元素将不会被排序作为排序的结果。
实现注意事项:这个实现是一个稳定的,自适应的,迭代的mergeesort,当输入数组被部分排序时,需要比n lg(n)的比较少得多,同时在输入数组被随机排列时提供传统的mergeesort的性能。 如果输入数组几乎被排序,则实现需要大致n个比较。 临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的n / 2对象引用。
该实现在其输入数组中具有上升和下降的同等优势,并且可以在同一输入数组的不同部分中利用升序和降序。 它非常适合合并两个或多个排序的数组:简单地连接数组并排序生成的数组。
该实现根据Tim Peters的Python列表( TimSort )进行了改编 。 它使用Peter McIlroy的“乐观排序和信息理论复杂性”中的技术,在第四届ACM-SIAM离散算法研讨会论文集,pp 467-474,1993年1月。
T
- 要排序的对象的类
a
- 要排序的数组
fromIndex
- 要排序的第一个元素(包括)的索引
toIndex
- 要排序的最后一个元素(排他)的索引
c
- 比较器来确定数组的顺序。
A null
值表示应使用元素' natural ordering '。
ClassCastException
- 如果数组包含使用指定的比较器不
相互比较的元素。
IllegalArgumentException
- 如果fromIndex > toIndex
或(可选)如果比较方发现违反Comparator
合同
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0
或
toIndex > a.length
public static <T> void parallelPrefix(T[] array, BinaryOperator<T> op)
[2, 1, 0, 3]
并且操作执行添加,则返回时,数组将保持[2, 3, 3, 6]
。
并行前缀计算通常比大数组的顺序循环更有效。
T
- 数组中对象的类
array
- 通过此方法就地修改的数组
op
- 一种无副作用的关联函数来执行累积
NullPointerException
- 如果指定的数组或函数为空
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
- 如果指定的数组或函数为空
public static void parallelPrefix(long[] array, LongBinaryOperator op)
[2, 1, 0, 3]
并且操作执行添加,则返回时,数组将保持[2, 3, 3, 6]
。
并行前缀计算通常比大数组的顺序循环更有效。
array
- 通过此方法被原位修改的数组
op
- 一种无副作用的关联函数来执行累积
NullPointerException
- 如果指定的数组或函数为空
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
- 如果指定的数组或函数为空
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
- 如果指定的数组或函数为空
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
- 如果指定的数组或函数为空
public static void parallelPrefix(int[] array, IntBinaryOperator op)
[2, 1, 0, 3]
并且操作执行添加,则返回时,数组将保持[2, 3, 3, 6]
。
并行前缀计算通常比大数组的顺序循环更有效。
array
- 通过此方法就地修改的数组
op
- 执行累积的无副作用的关联函数
NullPointerException
- 如果指定的数组或函数为空
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
- 如果指定的数组或函数为空
public static int binarySearch(long[] a, long key)
sort(long[])
方法进行排序。
如果没有排序,结果是未定义的。
如果数组包含具有指定值的多个元素,则不能保证将找到哪个元素。
a
- 要搜索的数组
key
- 要搜索的值
public static int binarySearch(long[] a, int fromIndex, int toIndex, long key)
sort(long[], int, int)
方法进行排序。
如果没有排序,结果是未定义的。
如果范围包含具有指定值的多个元素,则不能保证将找到哪个元素。
a
- 要搜索的数组
fromIndex
- 要搜索的第一个元素(包括)的索引
toIndex
- 要搜索的最后一个元素(排他)的索引
key
- 要搜索的值
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0 or toIndex > a.length
public static int binarySearch(int[] a, int key)
sort(int[])
方法)。
如果没有排序,结果是未定义的。
如果数组包含具有指定值的多个元素,则不能保证将找到哪个元素。
a
- 要搜索的数组
key
- 要搜索的值
public static int binarySearch(int[] a, int fromIndex, int toIndex, int key)
sort(int[], int, int)
方法进行排序。
如果没有排序,结果是未定义的。
如果范围包含具有指定值的多个元素,则不能保证将找到哪个元素。
a
- 要搜索的数组
fromIndex
- 要搜索的第一个元素(包括)的索引
toIndex
- 要搜索的最后一个元素(排他)的索引
key
- 要搜索的值
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0 or toIndex > a.length
public static int binarySearch(short[] a, short key)
sort(short[])
方法)。
如果没有排序,结果是未定义的。
如果数组包含具有指定值的多个元素,则不能保证将找到哪个元素。
a
- 要搜索的数组
key
- 要搜索的值
public static int binarySearch(short[] a, int fromIndex, int toIndex, short key)
sort(short[], int, int)
方法进行排序。
如果没有排序,结果是未定义的。
如果范围包含具有指定值的多个元素,则不能保证将找到哪个元素。
a
- 要搜索的数组
fromIndex
- 要搜索的第一个元素(包括)的索引
toIndex
- 要搜索的最后一个元素(排他)的索引
key
- 要搜索的值
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0 or toIndex > a.length
public static int binarySearch(char[] a, char key)
sort(char[])
方法)。
如果没有排序,结果是未定义的。
如果数组包含具有指定值的多个元素,则不能保证将找到哪个元素。
a
- 要搜索的数组
key
- 要搜索的值
public static int binarySearch(char[] a, int fromIndex, int toIndex, char key)
sort(char[], int, int)
方法进行排序。
如果没有排序,结果是未定义的。
如果范围包含具有指定值的多个元素,则不能保证将找到哪个元素。
a
- 要搜索的数组
fromIndex
- 要搜索的第一个元素(包括)的索引
toIndex
- 要搜索的最后一个元素(排他)的索引
key
- 要搜索的值
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0 or toIndex > a.length
public static int binarySearch(byte[] a, byte key)
sort(byte[])
方法进行排序。
如果没有排序,结果是未定义的。
如果数组包含具有指定值的多个元素,则不能保证将找到哪个元素。
a
- 要搜索的数组
key
- 要搜索的值
public static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
sort(byte[], int, int)
方法进行排序。
如果没有排序,结果是未定义的。
如果范围包含具有指定值的多个元素,则不能保证将找到哪个元素。
a
- 要搜索的数组
fromIndex
- 要搜索的第一个元素(包括)的索引
toIndex
- 要搜索的最后一个元素(排他)的索引
key
- 要搜索的值
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0 or toIndex > a.length
public static int binarySearch(double[] a, double key)
sort(double[])
方法)。
如果没有排序,结果是未定义的。
如果数组包含具有指定值的多个元素,则不能保证将找到哪个元素。
该方法认为所有的NaN值都是相等的。
a
- 要搜索的数组
key
- 要搜索的值
public static int binarySearch(double[] a, int fromIndex, int toIndex, double key)
sort(double[], int, int)
方法进行排序。
如果没有排序,结果是未定义的。
如果范围包含具有指定值的多个元素,则不能保证将找到哪个元素。
该方法认为所有的NaN值都是相等的。
a
- 要搜索的数组
fromIndex
- 要搜索的第一个元素(包括)的索引
toIndex
- 要搜索的最后一个元素(排他)的索引
key
- 要搜索的值
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0 or toIndex > a.length
public static int binarySearch(float[] a, float key)
sort(float[])
方法进行排序。
如果没有排序,结果是未定义的。
如果数组包含具有指定值的多个元素,则不能保证将找到哪个元素。
该方法认为所有的NaN值都是相等的。
a
- 要搜索的数组
key
- 要搜索的值
public static int binarySearch(float[] a, int fromIndex, int toIndex, float key)
sort(float[], int, int)
方法进行排序。
如果没有排序,结果是未定义的。
如果范围包含具有指定值的多个元素,则不能保证将找到哪个元素。
该方法认为所有的NaN值都是相等的。
a
- 要搜索的数组
fromIndex
- 要搜索的第一个元素(包括)的索引
toIndex
- 要搜索的最后一个元素(排他)的索引
key
- 要搜索的值
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0 or toIndex > a.length
public static int binarySearch(Object[] a, Object key)
sort(Object[])
方法)之前使该呼叫。
如果没有排序,结果是未定义的。
(如果数组包含不相互比较的元素(例如字符串和整数),则不能根据其元素的自然排序进行排序,因此结果未定义。)如果数组包含等于指定对象的多个元素,不能保证会找到哪一个。
a
- 要搜索的数组
key
- 要搜索的值
ClassCastException
- 如果搜索关键字与数组的元素无法比较。
public static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
sort(Object[], int, int)
方法)之前使该呼叫。
如果没有排序,结果是未定义的。
(如果范围包含不相互比较的元素(例如字符串和整数),则不能根据其元素的自然排序进行排序,因此结果未定义。)如果范围包含等于指定对象的多个元素,不能保证会找到哪一个。
a
- 要搜索的数组
fromIndex
- 要搜索的第一个元素(包括)的索引
toIndex
- 要搜索的最后一个元素(排他)的索引
key
- 要搜索的值
ClassCastException
- 如果搜索关键字与指定范围内的数组的元素不可比较。
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0 or toIndex > a.length
public static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)
sort(T[], Comparator)
方法)按升序排列。
如果没有排序,结果是未定义的。
如果数组包含与指定对象相等的多个元素,则不能保证将找到哪个元素。
T
- 数组中对象的类
a
- 要搜索的数组
key
- 要搜索的值
c
- 排列数组的比较器。
A null值表示应使用元素' natural ordering '。
ClassCastException
- 如果数组包含使用指定的比较器不
相互比较的元素,或者搜索关键字与使用该比较器的数组的元素不可比较。
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
- 排列数组的比较器。
A null值表示应使用元素' natural ordering '。
ClassCastException
- 如果范围包含使用指定的比较器不
相互比较的元素,或者搜索键与使用该比较器的范围内的元素不可比。
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0 or toIndex > a.length
public static boolean equals(long[] a, long[] a2)
a
- 要测试相等的一个数组
a2
- 要测试的其他数组的相等性
public static boolean equals(int[] a, int[] a2)
a
- 要测试相等的一个数组
a2
- 要测试的其他数组是否相等
public static boolean equals(short[] a, short[] a2)
a
- 要测试相等的一个数组
a2
- 要测试的其他数组是否相等
public static boolean equals(char[] a, char[] a2)
a
- 要测试相等的一个数组
a2
- 要进行相等测试的另一个数组
public static boolean equals(byte[] a, byte[] a2)
a
- 要进行相等测试的一个数组
a2
- 要测试的其他数组是否相等
public static boolean equals(boolean[] a, boolean[] a2)
a
- 要测试相等的一个数组
a2
- 要测试的其他数组是否相等
public static boolean equals(double[] a, double[] a2)
如果以下情况,两个双打d1和d2被认为是相等的
new Double(d1).equals(new Double(d2))
(与==运算符不同,该方法认为NaN等于自身,0.0d不等于-0.0d))
a
- 要测试相等的一个数组
a2
- 要测试的另一个数组是否相等
Double.equals(Object)
public static boolean equals(float[] a, float[] a2)
如下所示,两个浮标f1和f2被认为是相等的:
new Float(f1).equals(new Float(f2))
(与==运算符不同,此方法认为NaN等于自身,0.0f不等于-0.0f))
a
- 要测试相等的一个数组
a2
- 要测试的其他数组是否相等
Float.equals(Object)
public static boolean equals(Object[] a, Object[] a2)
a
- 要测试相等的一个数组
a2
- 要进行相等测试的另一个数组
public static void fill(long[] a, long val)
a
- 要填充的数组
val
- 要存储在数组的所有元素中的值
public static void fill(long[] a, int fromIndex, int toIndex, long val)
a
- 要填充的数组
fromIndex
- 要用指定值填充的第一个元素(包括)的索引
toIndex
- 要用指定值填充的最后一个元素(排他)的索引
val
- 要存储在数组的所有元素中的值
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果是
fromIndex < 0或
toIndex > a.length
public static void fill(int[] a, int val)
a
- 要填充的数组
val
- 要存储在数组的所有元素中的值
public static void fill(int[] a, int fromIndex, int toIndex, int val)
a
- 要填充的数组
fromIndex
- 要用指定值填充的第一个元素(包括)的索引
toIndex
- 要用指定值填充的最后一个元素(排除)的索引
val
- 要存储在数组的所有元素中的值
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0或
toIndex > a.length
public static void fill(short[] a, short val)
a
- 要填充的数组
val
- 要存储在数组的所有元素中的值
public static void fill(short[] a, int fromIndex, int toIndex, short val)
a
- 要填充的数组
fromIndex
- 要用指定值填充的第一个元素(包括)的索引
toIndex
- 要用指定值填充的最后一个元素(排除)的索引
val
- 要存储在数组的所有元素中的值
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0或
toIndex > a.length
public static void fill(char[] a, char val)
a
- 要填充的数组
val
- 要存储在数组的所有元素中的值
public static void fill(char[] a, int fromIndex, int toIndex, char val)
a
- 要填充的数组
fromIndex
- 要用指定值填充的第一个元素(包括)的索引
toIndex
- 要用指定值填充的最后一个元素(排他)的索引
val
- 要存储在数组的所有元素中的值
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0或
toIndex > a.length
public static void fill(byte[] a, byte val)
a
- 要填充的数组
val
- 要存储在数组的所有元素中的值
public static void fill(byte[] a, int fromIndex, int toIndex, byte val)
a
- 要填充的数组
fromIndex
- 要用指定值填充的第一个元素(包括)的索引
toIndex
- 要用指定值填充的最后一个元素(排除)的索引
val
- 要存储在数组的所有元素中的值
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0或
toIndex > a.length
public static void fill(boolean[] a, boolean val)
a
- 要填充的数组
val
- 要存储在数组的所有元素中的值
public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)
a
- 要填充的数组
fromIndex
- 要用指定值填充的第一个元素(含)的索引
toIndex
- 要用指定值填充的最后一个元素(排他)的索引
val
- 要存储在数组的所有元素中的值
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0或
toIndex > a.length
public static void fill(double[] a, double val)
a
- 要填充的数组
val
- 要存储在数组的所有元素中的值
public static void fill(double[] a, int fromIndex, int toIndex, double val)
a
- 要填充的数组
fromIndex
- 要用指定值填充的第一个元素(包括)的索引
toIndex
- 要用指定值填充的最后一个元素(排除)的索引
val
- 要存储在数组的所有元素中的值
IllegalArgumentException
- 如果是
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0或
toIndex > a.length
public static void fill(float[] a, float val)
a
- 要填充的数组
val
- 要存储在数组的所有元素中的值
public static void fill(float[] a, int fromIndex, int toIndex, float val)
a
- 要填充的数组
fromIndex
- 要用指定值填充的第一个元素(包括)的索引
toIndex
- 要用指定值填充的最后一个元素(排除)的索引
val
- 要存储在数组的所有元素中的值
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0或
toIndex > a.length
public static void fill(Object[] a, Object val)
a
- 要填充的数组
val
- 要存储在数组的所有元素中的值
ArrayStoreException
- 如果指定的值不是可以存储在指定数组中的运行时类型
public static void fill(Object[] a, int fromIndex, int toIndex, Object val)
a
- 要填充的数组
fromIndex
- 要用指定值填充的第一个元素(包括)的索引
toIndex
- 要用指定值填充的最后一个元素(排除)的索引
val
- 要存储在数组的所有元素中的值
IllegalArgumentException
- 如果
fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果
fromIndex < 0或
toIndex > a.length
ArrayStoreException
- 如果指定的值不是可以存储在指定数组中的运行时类型
public static <T> T[] copyOf(T[] original, int newLength)
T
- 数组中对象的类
original
- 要复制的数组
newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果
newLength为负数
NullPointerException
- 如果
original为空
public static <T,U> T[] copyOf(U[] original, int newLength, 类<? extends T[]> newType)
U
- 原始数组中对象的类
T
- 返回数组中对象的类
original
- 要复制的数组
newLength
- 要返回的副本的长度
newType
- 要返回的副本的类
NegativeArraySizeException
- 如果
newLength为负数
NullPointerException
- 如果
original为空
ArrayStoreException
- 如果从
original复制的元素不是可以存储在类别
newType的数组中的运行时类型
public static byte[] copyOf(byte[] original, int newLength)
original
- 要复制的数组
newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果
newLength为负数
NullPointerException
- 如果
original为空
public static short[] copyOf(short[] original, int newLength)
original
- 要复制的数组
newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果
newLength为负数
NullPointerException
- 如果
original为空
public static int[] copyOf(int[] original, int newLength)
original
- 要复制的数组
newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果
newLength为负数
NullPointerException
- 如果
original为空
public static long[] copyOf(long[] original, int newLength)
original
- 要复制的数组
newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果
newLength为负数
NullPointerException
- 如果
original为空
public static char[] copyOf(char[] original, int newLength)
original
- 要复制的数组
newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果
newLength是否定的
NullPointerException
- 如果
original为空
public static float[] copyOf(float[] original, int newLength)
original
- 要复制的数组
newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果
newLength为负数
NullPointerException
- 如果
original为空
public static double[] copyOf(double[] original, int newLength)
original
- 要复制的数组
newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果
newLength为负数
NullPointerException
- 如果
original为空
public static boolean[] copyOf(boolean[] original, int newLength)
original
- 要复制的数组
newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果
newLength为负数
NullPointerException
- 如果
original为空
public static <T> T[] copyOfRange(T[] original, int from, int to)
结果数组与原始数组完全相同的类。
T
- 数组中对象的类
original
- 要从中复制范围的数组
from
- 要复制的范围的初始索引(包括)
to
- 要复制的范围的最终索引,排他。
(该索引可能位于数组之外)
ArrayIndexOutOfBoundsException
- 如果
from < 0
或
from > original.length
IllegalArgumentException
- 如果是
from > to
NullPointerException
- 如果
original为空
public static <T,U> T[] copyOfRange(U[] original, int from, int to, 类<? extends T[]> newType)
U
- 原始数组中对象的类
T
- 返回数组中对象的类
original
- 要从中复制范围的数组
from
- 要复制的范围的初始索引(包括)
to
- 要复制的范围的最终索引,排他。
(该索引可能位于数组之外)
newType
- 要返回的副本的类
ArrayIndexOutOfBoundsException
- 如果
from < 0
或
from > original.length
IllegalArgumentException
- 如果
from > to
NullPointerException
- 如果
original为空
ArrayStoreException
- 如果从
original复制的元素不是可以存储在类别
newType的数组中的运行时类型。
public static byte[] copyOfRange(byte[] original, int from, int to)
original
- 要从中复制范围的数组
from
- 要复制的范围的初始索引(包括)
to
- 要复制的范围的最终索引,排他。
(该索引可能位于数组之外)
ArrayIndexOutOfBoundsException
- 如果
from < 0
或
from > original.length
IllegalArgumentException
- 如果
from > to
NullPointerException
- 如果
original为空
public static short[] copyOfRange(short[] original, int from, int to)
original
- 要从中复制范围的数组
from
- 要复制的范围的初始索引(包括)
to
- 要复制的范围的最终索引,排他。
(该索引可能位于数组之外)
ArrayIndexOutOfBoundsException
- 如果
from < 0
或
from > original.length
IllegalArgumentException
- 如果
from > to
NullPointerException
- 如果
original为空
public static int[] copyOfRange(int[] original, int from, int to)
original
- 要从中复制范围的数组
from
- 要复制的范围的初始索引(包括)
to
- 要复制的范围的最终索引,排他。
(该索引可能位于数组之外)
ArrayIndexOutOfBoundsException
- 如果
from < 0
或
from > original.length
IllegalArgumentException
- 如果
from > to
NullPointerException
- 如果
original为空
public static long[] copyOfRange(long[] original, int from, int to)
original
- 要从中复制范围的数组
from
- 要复制的范围的初始索引(包括)
to
- 要复制的范围的最终索引,排他。
(该索引可能位于数组之外)
ArrayIndexOutOfBoundsException
- 如果
from < 0
或
from > original.length
IllegalArgumentException
- 如果
from > to
NullPointerException
- 如果
original为空
public static char[] copyOfRange(char[] original, int from, int to)
original
- 要从中复制范围的数组
from
- 要复制的范围的初始索引(包括)
to
- 要复制的范围的最终索引,排他。
(该索引可能位于数组之外)
ArrayIndexOutOfBoundsException
- 如果
from < 0
或
from > original.length
IllegalArgumentException
- 如果
from > to
NullPointerException
- 如果
original为空
public static float[] copyOfRange(float[] original, int from, int to)
original
- 要从中复制范围的数组
from
- 要复制的范围的初始索引(包括)
to
- 要复制的范围的最终索引,排他。
(该索引可能位于数组之外)
ArrayIndexOutOfBoundsException
- 如果
from < 0
或
from > original.length
IllegalArgumentException
- 如果
from > to
NullPointerException
- 如果
original为空
public static double[] copyOfRange(double[] original, int from, int to)
original
- 要从中复制范围的数组
from
- 要复制的范围的初始索引(包括)
to
- 要复制的范围的最终索引,排他。
(该索引可能位于数组之外)
ArrayIndexOutOfBoundsException
- 如果
from < 0
或
from > original.length
IllegalArgumentException
- 如果
from > to
NullPointerException
- 如果
original为空
public static boolean[] copyOfRange(boolean[] original, int from, int to)
original
- 要从中复制范围的数组
from
- 要复制的范围的初始索引(包括)
to
- 要复制的范围的最终索引,排他。
(该索引可能位于数组之外)
ArrayIndexOutOfBoundsException
- 如果
from < 0
或
from > original.length
IllegalArgumentException
- 如果是
from > to
NullPointerException
- 如果
original为空
@SafeVarargs public static <T> List<T> asList(T... a)
Collection.toArray()
相结合 。
返回的列表是可序列化的,并实现RandomAccess
。
此方法还提供了一种方便的方式来创建一个初始化为包含几个元素的固定大小的列表:
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
T
- 数组中对象的类
a
- 列表将被支持的数组
public static int hashCode(long[] a)
通过此方法返回的值是将通过调用能够得到相同的值hashCode
上的方法List
含有序列Long
个实例表示的a以相同顺序的元素。 如果a是null ,则此方法返回0。
a
- 要计算的哈希值的数组
public static int hashCode(int[] a)
通过此方法返回的值是将通过调用能够得到相同的值hashCode
上的方法List
含有序列Integer
个实例表示的a以相同顺序的元素。 如果a为null ,则此方法返回0。
a
- 要计算的哈希值的数组
public static int hashCode(short[] a)
通过此方法返回的值是将通过调用能够得到相同的值hashCode
上的方法List
含有序列Short
个实例表示的a以相同顺序的元素。 如果a为null ,则此方法返回0。
a
- 要计算的哈希值的数组
public static int hashCode(char[] a)
通过此方法返回的值是将通过调用能够得到相同的值hashCode
上的方法List
含有序列Character
个实例表示的a以相同顺序的元素。 如果a为null ,则此方法返回0。
a
- 要计算的哈希值的数组
public static int hashCode(byte[] a)
通过此方法返回的值是将通过调用能够得到相同的值hashCode
上的方法List
含有序列Byte
个实例表示的a以相同顺序的元素。 如果a为null ,则此方法返回0。
a
- 要计算的哈希值的数组
public static int hashCode(boolean[] a)
此方法返回的值与通过在同一顺序中包含 Boolean
表达a元素的88446024714736的一个List
调用hashCode
方法获得的值相同。 如果a为null ,则此方法返回0。
a
- 要计算的哈希值的数组
public static int hashCode(float[] a)
通过此方法返回的值是将通过调用能够得到相同的值hashCode
上的方法List
含有序列Float
个实例表示的a以相同顺序的元素。 如果a为null ,则此方法返回0。
a
- 要计算的哈希值的数组
public static int hashCode(double[] a)
通过此方法返回的值是将通过调用能够得到相同的值hashCode
上的方法List
含有序列Double
个实例表示的a以相同顺序的元素。 如果a为null ,则此方法返回0。
a
- 要计算的哈希值的数组
public static int hashCode(Object[] a)
对于任何两个阵列a和b等Arrays.equals(a, b) ,也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。
通过此方法返回的值等于将由Arrays.asList(a).hashCode()被返回,除非a null是,在这种情况下是0返回的值。
a
- 要计算的基于内容的哈希码的数组
deepHashCode(Object[])
public static int deepHashCode(Object[] a)
对于任何两个阵列a和b等Arrays.deepEquals(a, b) ,也是Arrays.deepHashCode(a) == Arrays.deepHashCode(b)的情况。
通过此方法返回的值的计算是类似于由返回的值的List.hashCode()
包含相同的元素如a以相同的顺序在列表上,有一点不同:如果一个元素的a e本身是一个阵列,其散列代码不是通过调用e.hashCode()计算的,而是通过调用Arrays.hashCode(e)的适当重载(如果e是原始类型的数组),或者通过递归调用Arrays.deepHashCode(e),如果e是引用类型的数组。 如果a为null ,则此方法返回0。
a
- 其基于深度内容的哈希码计算的阵列
hashCode(Object[])
public static boolean deepEquals(Object[] a1, Object[] a2)
equals(Object[],Object[])
方法不同,该方法适用于任意深度的嵌套数组。
如果两者都是null ,或者如果它们是指包含相同数量的元素的数组,并且两个数组中所有对应的元素对都相等,则两个数组引用被认为是相当相等的。
如果以下任一条件成立 ,两个可能的null元素e1和e2都是相当的:
如果任一指定的数组通过一个或多个数组级别直接或间接包含自身作为元素,则此方法的行为是未定义的。
a1
- 要测试相等的一个数组
a2
- 要测试的其他数组是否相等
equals(Object[],Object[])
,
Objects.deepEquals(Object, Object)
public static String toString(long[] a)
a
- 要返回的字符串表示形式的数组
public static String toString(int[] a)
a
- 要返回其字符串表示形式的数组
public static String toString(short[] a)
a
- 要返回的字符串表示形式的数组
public static String toString(char[] a)
a
- 要返回的字符串表示形式的数组
public static String toString(byte[] a)
a
- 要返回其字符串表示形式的数组
public static String toString(boolean[] a)
a
- 要返回的字符串表示形式的数组
public static String toString(float[] a)
a
- 要返回的字符串表示形式的数组
public static String toString(double[] a)
a
- 要返回的字符串表示形式的数组
public static String toString(Object[] a)
Object.toString()
从Object继承的方法,其描述了他们的身份 ,而不是其内容。
通过此方法返回的值等于将由Arrays.asList(a).toString()被返回,除非a null是,在这种情况下是"null"返回的值。
a
- 要返回的字符串表示形式的数组
deepToString(Object[])
public static String deepToString(Object[] a)
字符串表示由数组元素的列表组成,括在方括号( "[]" )中。 相邻的元素由字符", " (逗号后跟一个空格)分隔开。 元件由String.valueOf(Object)转换为字符串,除非它们本身阵列。
如果一个元素e是一个基本类型的阵列,它通过调用的Arrays.toString(e)适当重载转换为字符串作为。 如果元素e是引用类型的数组,则通过递归调用此方法将其转换为字符串。
为了避免无限递归,如果指定的数组包含自身作为元素,或者通过一个或多个数组级别包含对其自身的间接引用,则将自引用转换为字符串"[...]" 。 例如,仅包含对其自身的引用的数组将被呈现为"[[...]]" 。
如果指定数组是null此方法返回"null"。
a
- 要返回的字符串表示形式的数组
toString(Object[])
public static <T> void setAll(T[] array, IntFunction<? extends T> generator)
如果生成器函数引发异常,则将其转发给调用者,并将数组置于不确定状态。
T
- 数组元素的类型
array
- 要初始化的数组
generator
- 接受索引并产生该位置所需值的函数
NullPointerException
- 如果生成器为空
public static <T> void parallelSetAll(T[] array, IntFunction<? extends T> generator)
如果发电机功能抛出异常,一个未经检查的异常是从抛出parallelSetAll
和阵列保持处于不确定状态。
T
- 数组元素的类型
array
- 要初始化的数组
generator
- 接受索引并产生该位置所需值的函数
NullPointerException
- 如果生成器为空
public static void setAll(int[] array, IntUnaryOperator generator)
如果生成器函数引发异常,则将其转发给调用者,并将数组置于不确定状态。
array
- 要初始化的数组
generator
- 接受索引并产生该位置所需值的函数
NullPointerException
- 如果生成器为空
public static void parallelSetAll(int[] array, IntUnaryOperator generator)
如果生成器函数引发异常,则会从parallelSetAll
抛出未检查的异常,并将数组置于不确定状态。
array
- 要初始化的数组
generator
- 接受索引并产生该位置所需值的函数
NullPointerException
- 如果生成器为空
public static void setAll(long[] array, IntToLongFunction generator)
如果生成器函数引发异常,则将其转发给调用者,并将数组置于不确定状态。
array
- 要初始化的数组
generator
- 接受索引并产生该位置所需值的函数
NullPointerException
- 如果生成器为空
public static void parallelSetAll(long[] array, IntToLongFunction generator)
如果生成器函数引发异常,则会从parallelSetAll
抛出未检查的异常,并将数组置于不确定状态。
array
- 要初始化的数组
generator
- 接受索引并产生该位置所需值的函数
NullPointerException
- 如果生成器为空
public static void setAll(double[] array, IntToDoubleFunction generator)
如果生成器函数引发异常,则将其转发给调用者,并将数组置于不确定状态。
array
- 要初始化的数组
generator
- 接受索引并产生该位置所需值的函数
NullPointerException
- 如果生成器为空
public static void parallelSetAll(double[] array, IntToDoubleFunction generator)
如果生成器函数引发异常,则会从parallelSetAll
抛出未检查的异常,并且数组处于不确定状态。
array
- 要初始化的数组
generator
- 接受索引并产生该位置的期望值的函数
NullPointerException
- 如果生成器为空
public static <T> Spliterator<T> spliterator(T[] array)
Spliterator
覆盖所有指定数组。
该报告spliterator Spliterator.SIZED
, Spliterator.SUBSIZED
, Spliterator.ORDERED
和Spliterator.IMMUTABLE
。
T
- 元素的类型
array
- 假定在使用过程中
array
的数组
public static <T> Spliterator<T> spliterator(T[] array, int startInclusive, int endExclusive)
Spliterator
覆盖指定数组的指定范围内。
该报告spliterator Spliterator.SIZED
, Spliterator.SUBSIZED
, Spliterator.ORDERED
和Spliterator.IMMUTABLE
。
T
- 元素的类型
array
- 假定在使用过程中
array
的数组
startInclusive
- 第一个涵盖的索引
endExclusive
- 索引紧随上一个索引覆盖
ArrayIndexOutOfBoundsException
- 如果
startInclusive
为负数,则
endExclusive
小于
startInclusive
,或
endExclusive
大于数组大小
public static Spliterator.OfInt spliterator(int[] array)
Spliterator.OfInt
覆盖所有指定数组。
该报告spliterator Spliterator.SIZED
, Spliterator.SUBSIZED
, Spliterator.ORDERED
和Spliterator.IMMUTABLE
。
array
- 假定在使用期间
array
的数组
public static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive)
Spliterator.OfInt
覆盖指定数组的指定范围内。
该报告spliterator Spliterator.SIZED
, Spliterator.SUBSIZED
, Spliterator.ORDERED
和Spliterator.IMMUTABLE
。
array
- 假定在使用过程中
array
的数组
startInclusive
- 第一个涵盖的索引
endExclusive
- 索引立即通过最后一个索引覆盖
ArrayIndexOutOfBoundsException
- 如果
startInclusive
为负数,则
endExclusive
小于
startInclusive
,或
endExclusive
大于数组大小
public static Spliterator.OfLong spliterator(long[] array)
Spliterator.OfLong
覆盖所有指定数组。
该报告spliterator Spliterator.SIZED
, Spliterator.SUBSIZED
, Spliterator.ORDERED
和Spliterator.IMMUTABLE
。
array
- 假定在使用过程中
array
的数组
public static Spliterator.OfLong spliterator(long[] array, int startInclusive, int endExclusive)
Spliterator.OfLong
覆盖指定数组的指定范围内。
该报告spliterator Spliterator.SIZED
, Spliterator.SUBSIZED
, Spliterator.ORDERED
和Spliterator.IMMUTABLE
。
array
- 假定在使用期间
array
的数组
startInclusive
- 第一个涵盖的索引
endExclusive
- 索引立即通过最后一个索引覆盖
ArrayIndexOutOfBoundsException
- 如果
startInclusive
为负数,则
endExclusive
小于
startInclusive
,或
endExclusive
大于阵列大小
public static Spliterator.OfDouble spliterator(double[] array)
Spliterator.OfDouble
覆盖所有指定数组。
该报告spliterator Spliterator.SIZED
, Spliterator.SUBSIZED
, Spliterator.ORDERED
和Spliterator.IMMUTABLE
。
array
- 假定在使用过程中
array
的数组
public static Spliterator.OfDouble spliterator(double[] array, int startInclusive, int endExclusive)
Spliterator.OfDouble
覆盖指定数组的指定范围内。
该报告spliterator Spliterator.SIZED
, Spliterator.SUBSIZED
, Spliterator.ORDERED
和Spliterator.IMMUTABLE
。
array
- 假定在使用期间
array
的数组
startInclusive
- 第一个涵盖的索引
endExclusive
- 索引立即通过最后一个索引覆盖
ArrayIndexOutOfBoundsException
- 如果
startInclusive
为负数,则
endExclusive
小于
startInclusive
,或
endExclusive
大于数组大小
public static <T> Stream<T> stream(T[] array)
Stream
与指定的数组作为源。
T
- 数组元素的类型
array
- 假定在使用过程中
array
的数组
Stream
的阵列
public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive)
Stream
与指定的数组作为源的指定范围。
T
- 数组元素的类型
array
- 假定在使用过程中
array
的数组
startInclusive
- 第一个涵盖的索引
endExclusive
- 索引立即通过最后一个索引覆盖
Stream
的数组范围
ArrayIndexOutOfBoundsException
- 如果
startInclusive
为负数,则
endExclusive
小于
startInclusive
,或
endExclusive
大于数组大小
public static IntStream stream(int[] array)
IntStream
与指定的数组作为源。
array
- 假定在使用过程中
array
的数组
IntStream
的数组
public static IntStream stream(int[] array, int startInclusive, int endExclusive)
IntStream
与指定的数组作为源的指定范围。
array
- 假定在使用期间
array
的数组
startInclusive
- 第一个涵盖的索引
endExclusive
- 索引立即通过最后一个索引覆盖
IntStream
的阵列范围
ArrayIndexOutOfBoundsException
- 如果
startInclusive
为负数,则
endExclusive
小于
startInclusive
,或
endExclusive
大于数组大小
public static LongStream stream(long[] array)
LongStream
与指定的数组作为源。
array
- 假定在使用期间
array
的数组
LongStream
的阵列
public static LongStream stream(long[] array, int startInclusive, int endExclusive)
LongStream
与指定的数组作为源的指定范围。
array
- 假定在使用期间
array
的数组
startInclusive
- 第一个涵盖的索引
endExclusive
- 索引立即通过最后一个索引覆盖
LongStream
的数组范围
ArrayIndexOutOfBoundsException
- 如果
startInclusive
为负数,则
endExclusive
小于
startInclusive
,或
endExclusive
大于数组大小
public static DoubleStream stream(double[] array)
DoubleStream
与指定的数组作为源。
array
- 假定在使用过程中
array
的数组
DoubleStream
的数组
public static DoubleStream stream(double[] array, int startInclusive, int endExclusive)
DoubleStream
与指定的数组作为源的指定范围。
array
- 假定在使用过程中
array
的数组
startInclusive
- 第一个涵盖的索引
endExclusive
- 索引立即通过最后一个索引覆盖
DoubleStream
的阵列范围
ArrayIndexOutOfBoundsException
- 如果
startInclusive
为负数,则
endExclusive
小于
startInclusive
,或
endExclusive
大于数组大小
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.