鸿蒙OS Arrays
Arrays
java.lang.Object
|---java.util.Arrays
public class Arrays
extends Object此类包含用于操作数组（例如排序和搜索）的各种方法。 此类还包含一个允许将数组视为列表的静态工厂。
如果指定的数组引用为空，则此类中的方法都会抛出 NullPointerException，除非另有说明。
此类中包含的方法的文档包括实现的简要说明。 此类描述应被视为实现说明，而不是规范的一部分。 只要遵守规范本身，实现者应该可以随意替换其他算法。 （例如，sort(Object[]) 使用的算法不必是 MergeSort，但它必须是稳定的。）
此类是 Java 集合框架的成员。
方法总结
| 修饰符和类型 | 方法 | 描述 |
|---|---|---|
| static <T> List<T> | asList(T... a) | 返回由指定数组支持的固定大小的列表。 |
| static int | binarySearch(byte[] a, byte key) | 使用二进制搜索算法在指定的字节数组中搜索指定的值。 |
| static int | binarySearch(byte[] a, int fromIndex, int toIndex, byte key) | 使用二进制搜索算法在指定字节数组的范围内搜索指定值。 |
| static int | binarySearch(char[] a, char key) | 使用二进制搜索算法在指定的字符数组中搜索指定的值。 |
| static int | binarySearch(char[] a, int fromIndex, int toIndex, char key) | 使用二进制搜索算法在指定字符数组的范围内搜索指定值。 |
| static int | binarySearch(double[] a, double key) | 使用二进制搜索算法在指定的双精度数组中搜索指定的值。 |
| static int | binarySearch(double[] a, int fromIndex, int toIndex, double key) | 使用二分搜索算法在指定的双精度数组范围内搜索指定值。 |
| static int | binarySearch(float[] a, float key) | 使用二进制搜索算法在指定的浮点数数组中搜索指定的值。 |
| static int | binarySearch(float[] a, int fromIndex, int toIndex, float key) | 使用二分搜索算法在指定浮点数数组的范围内搜索指定值。 |
| static int | binarySearch(int[] a, int key) | 使用二进制搜索算法在指定的整数数组中搜索指定的值。 |
| static int | binarySearch(int[] a, int fromIndex, int toIndex, int key) | 使用二进制搜索算法在指定整数数组的范围内搜索指定值。 |
| static int | binarySearch(long[] a, int fromIndex, int toIndex, long key) | 使用二进制搜索算法在指定的 long 数组的范围内搜索指定值。 |
| static int | binarySearch(long[] a, long key) | 使用二进制搜索算法在指定的 long 数组中搜索指定的值。 |
| static int | binarySearch(short[] a, int fromIndex, int toIndex, short key) | 使用二分搜索算法在指定的 short 数组的范围内搜索指定的值。 |
| 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 boolean[] | copyOf(boolean[] original, int newLength) | 复制指定的数组，用 false 截断或填充（如果需要），使副本具有指定的长度。 |
| static byte[] | copyOf(byte[] original, int newLength) | 复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 |
| static char[] | copyOf(char[] original, int newLength) | 复制指定的数组，用空字符截断或填充（如有必要），使副本具有指定的长度。 |
| static double[] | copyOf(double[] original, int newLength) | 复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 |
| static float[] | copyOf(float[] original, int newLength) | 复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 |
| static int[] | copyOf(int[] original, int newLength) | 复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 |
| static long[] | copyOf(long[] original, int newLength) | 复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 |
| static short[] | copyOf(short[] original, int newLength) | 复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 |
| static <T> T[] | copyOf(T[] original, int newLength) | 复制指定的数组，截断或填充空值（如有必要），使副本具有指定的长度。 |
| static <T,U> T[] | copyOf(U[] original, int newLength, Class<? extends T[]> newType) | 复制指定的数组，截断或填充空值（如有必要），使副本具有指定的长度。 |
| static boolean[] | copyOfRange(boolean[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static byte[] | copyOfRange(byte[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static char[] | copyOfRange(char[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static double[] | copyOfRange(double[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static float[] | copyOfRange(float[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static int[] | copyOfRange(int[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static long[] | copyOfRange(long[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static short[] | copyOfRange(short[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static <T> T[] | copyOfRange(T[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static <T,U> T[] | copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) | 将指定数组的指定范围复制到新数组中。 |
| static boolean | deepEquals(Object[] a1, Object[] a2) | 如果两个指定的数组彼此深度相等，则返回 true。 |
| static int | deepHashCode(Object[] a) | 根据指定数组的“深层内容”返回哈希码。 |
| static String | deepToString(Object[] a) | 返回指定数组的“深层内容”的字符串表示形式。 |
| static boolean | equals(boolean[] a, boolean[] a2) | 如果两个指定的布尔值数组彼此相等，则返回 true。 |
| static boolean | equals(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) | 如果两个指定的 long 数组彼此相等，则返回 true。 |
| static boolean | equals(short[] a, short[] a2) | 如果两个指定的 short 数组彼此相等，则返回 true。 |
| static boolean | equals(Object[] a, Object[] a2) | 如果两个指定的 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 值分配给指定的 char 数组的每个元素。 |
| static void | fill(char[] a, int fromIndex, int toIndex, char val) | 将指定的 char 值分配给指定字符数组的指定范围的每个元素。 |
| 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) | 将指定的浮点值分配给指定浮点数组的每个元素。 |
| 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 值分配给指定 long 数组的指定范围的每个元素。 |
| static void | fill(long[] a, long val) | 将指定的 long 值分配给指定的 long 数组的每个元素。 |
| 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 引用分配给指定的 Objects 数组的指定范围内的每个元素。 |
| 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 void | parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op) | 对数组的给定子范围执行 [parallelPrefix(double],java.util.function.DoubleBinaryOperator)。 |
| static void | parallelPrefix(double[] array, DoubleBinaryOperator op) | 使用提供的函数并行累积给定数组的每个元素。 |
| static void | parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op) | 对数组的给定子范围执行 [parallelPrefix(int],java.util.function.IntBinaryOperator)。 |
| static void | parallelPrefix(int[] array, IntBinaryOperator op) | 使用提供的函数并行累积给定数组的每个元素。 |
| static void | parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op) | 对数组的给定子范围执行 [parallelPrefix(long],java.util.function.LongBinaryOperator)。 |
| static void | parallelPrefix(long[] array, LongBinaryOperator op) | 使用提供的函数并行累积给定数组的每个元素。 |
| static <T> void | parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op) | 对数组的给定子范围执行 [parallelPrefix(java.lang.Object],java.util.function.BinaryOperator)。 |
| static <T> void | parallelPrefix(T[] array, BinaryOperator<T> op) | 使用提供的函数并行累积给定数组的每个元素。 |
| static void | parallelSetAll(double[] array, IntToDoubleFunction generator) | 使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。 |
| static void | parallelSetAll(int[] array, IntUnaryOperator generator) | 使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。 |
| static void | parallelSetAll(long[] array, IntToLongFunction generator) | 使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。 |
| static <T> void | parallelSetAll(T[] array, IntFunction<? extends T> generator) | 使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。 |
| static void | parallelSort(byte[] a) | 将指定的数组按数字升序排序。 |
| static void | parallelSort(byte[] a, int fromIndex, int toIndex) | 将数组的指定范围按数字升序排序。 |
| static void | parallelSort(char[] a) | 将指定的数组按数字升序排序。 |
| static void | parallelSort(char[] a, int fromIndex, int toIndex) | 将数组的指定范围按数字升序排序。 |
| static void | parallelSort(double[] a) | 将指定的数组按数字升序排序。 |
| static void | parallelSort(double[] a, int fromIndex, int toIndex) | 将数组的指定范围按数字升序排序。 |
| static void | parallelSort(float[] a) | 将指定的数组按数字升序排序。 |
| static void | parallelSort(float[] a, int fromIndex, int toIndex) | 将数组的指定范围按数字升序排序。 |
| static void | parallelSort(int[] a) | 将指定的数组按数字升序排序。 |
| static void | parallelSort(int[] a, int fromIndex, int toIndex) | 将数组的指定范围按数字升序排序。 |
| static void | parallelSort(long[] a) | 将指定的数组按数字升序排序。 |
| static void | parallelSort(long[] a, int fromIndex, int toIndex) | 将数组的指定范围按数字升序排序。 |
| static void | parallelSort(short[] a) | 将指定的数组按数字升序排序。 |
| static void | parallelSort(short[] a, int fromIndex, int toIndex) | 将数组的指定范围按数字升序排序。 |
| static <T extends Comparable<? super T>>void | parallelSort(T[] a) | 根据其元素的 Comparable 对指定的对象数组进行升序排序。 |
| static <T extends Comparable<? super T>>void | parallelSort(T[] a, int fromIndex, int toIndex) | 根据其元素的 Comparable 对指定对象数组的指定范围进行升序排序。 |
| 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) | 根据其元素的 Comparable 对指定的对象数组进行升序排序。 |
| static void | sort(Object[] a, int fromIndex, int toIndex) | 根据其元素的 Comparable 对指定对象数组的指定范围进行升序排序。 |
| 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) | 返回以指定数组为源的顺序流。 |
| static <T> Stream<T> | stream(T[] array, int startInclusive, int endExclusive) | 返回以指定数组的指定范围作为源的顺序流。 |
| 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) | 返回指定数组内容的字符串表示形式。 |
| 从类 java.lang.Object 继承的方法 |
|---|
| clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
方法详情
sort
public static void sort(int[] a)
将指定的数组按数字升序排序。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
sort
public static void sort(int[] a, int fromIndex, int toIndex)
将数组的指定范围按升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
sort
public static void sort(long[] a)
将指定的数组按数字升序排序。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
sort
public static void sort(long[] a, int fromIndex, int toIndex)
将数组的指定范围按升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
sort
public static void sort(short[] a)
将指定的数组按数字升序排序。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
sort
public static void sort(short[] a, int fromIndex, int toIndex)
将数组的指定范围按升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
sort
public static void sort(char[] a)
将指定的数组按数字升序排序。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
sort
public static void sort(char[] a, int fromIndex, int toIndex)
将数组的指定范围按升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
sort
public static void sort(byte[] a)
将指定的数组按数字升序排序。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
sort
public static void sort(byte[] a, int fromIndex, int toIndex)
将数组的指定范围按升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
sort
public static void sort(float[] a)
将指定的数组按数字升序排序。
< 关系不提供所有浮点值的总顺序：-0.0f == 0.0f 为真，并且 Float.NaN 值比较不小于、大于或等于任何值，甚至它本身。 此方法使用 Float#compareTo 方法施加的总顺序：-0.0f 被视为小于值 0.0f，Float.NaN 被视为大于任何其他值，并且所有 Float.NaN 值被视为相等。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
sort
public static void sort(float[] a, int fromIndex, int toIndex)
将数组的指定范围按升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
< 关系不提供所有浮点值的总顺序：-0.0f == 0.0f 为真，并且 Float.NaN 值比较不小于、大于或等于任何值，甚至它本身。 此方法使用 Float#compareTo 方法施加的总顺序：-0.0f 被视为小于值 0.0f，Float.NaN 被视为大于任何其他值，并且所有 Float.NaN 值被视为相等。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
sort
public static void sort(double[] a)
将指定的数组按数字升序排序。
< 关系不提供所有双精度值的总顺序：-0.0d == 0.0d 为真，并且 Double.NaN 值比较不小于、大于或等于任何值，甚至它本身。 此方法使用 Double#compareTo 方法施加的总顺序：-0.0d 被视为小于值 0.0d，Double.NaN 被视为大于任何其他值，并且所有 Double.NaN 值被视为相等。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
sort
public static void sort(double[] a, int fromIndex, int toIndex)
将数组的指定范围按升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
< 关系不提供所有双精度值的总顺序：-0.0d == 0.0d 为真，并且 Double.NaN 值比较不小于、大于或等于任何值，甚至它本身。 此方法使用 Double#compareTo 方法施加的总顺序：-0.0d 被视为小于值 0.0d，Double.NaN 被视为大于任何其他值，并且所有 Double.NaN 值被视为相等。
实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
parallelSort
public static void parallelSort(byte[] a)
将指定的数组按数字升序排序。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
parallelSort
public static void parallelSort(byte[] a, int fromIndex, int toIndex)
将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
parallelSort
public static void parallelSort(char[] a)
将指定的数组按数字升序排序。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
parallelSort
public static void parallelSort(char[] a, int fromIndex, int toIndex)
将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
parallelSort
public static void parallelSort(short[] a)
将指定的数组按数字升序排序。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
parallelSort
public static void parallelSort(short[] a, int fromIndex, int toIndex)
将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
parallelSort
public static void parallelSort(int[] a)
将指定的数组按数字升序排序。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
parallelSort
public static void parallelSort(int[] a, int fromIndex, int toIndex)
将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
parallelSort
public static void parallelSort(long[] a)
将指定的数组按数字升序排序。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
parallelSort
public static void parallelSort(long[] a, int fromIndex, int toIndex)
将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
parallelSort
public static void parallelSort(float[] a)
将指定的数组按数字升序排序。
< 关系不提供所有浮点值的总顺序：-0.0f == 0.0f 为真，并且 Float.NaN 值比较不小于、大于或等于任何值，甚至它本身。 此方法使用 Float#compareTo 方法施加的总顺序：-0.0f 被视为小于值 0.0f，Float.NaN 被视为大于任何其他值，并且所有 Float.NaN 值被视为相等。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
parallelSort
public static void parallelSort(float[] a, int fromIndex, int toIndex)
将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
< 关系不提供所有浮点值的总顺序：-0.0f == 0.0f 为真，并且 Float.NaN 值比较不小于、大于或等于任何值，甚至它本身。 此方法使用 Float#compareTo 方法施加的总顺序：-0.0f 被视为小于值 0.0f，Float.NaN 被视为大于任何其他值，并且所有 Float.NaN 值被视为相等。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
parallelSort
public static void parallelSort(double[] a)
将指定的数组按数字升序排序。
< 关系不提供所有双精度值的总顺序：-0.0d == 0.0d 为真，并且 Double.NaN 值比较不小于、大于或等于任何值，甚至它本身。 此方法使用 Double#compareTo 方法施加的总顺序：-0.0d 被视为小于值 0.0d，Double.NaN 被视为大于任何其他值，并且所有 Double.NaN 值被视为相等。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
parallelSort
public static void parallelSort(double[] a, int fromIndex, int toIndex)
将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。
< 关系不提供所有双精度值的总顺序：-0.0d == 0.0d 为真，并且 Double.NaN 值比较不小于、大于或等于任何值，甚至它本身。 此方法使用 Double#compareTo 方法施加的总顺序：-0.0d 被视为小于值 0.0d，Double.NaN 被视为大于任何其他值，并且所有 Double.NaN 值被视为相等。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素的索引，排他性 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
parallelSort
public static <T extends Comparable<? super T>> void parallelSort(T[] a)
根据其元素的 Comparable 对指定的对象数组进行升序排序。 数组中的所有元素都必须实现 Comparable 接口。 此外，数组中的所有元素必须相互可比较（即，e1.compareTo(e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。
这种排序保证是稳定的：相同的元素不会因为排序而重新排序。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 要排序的对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ClassCastException | 如果数组包含不可相互比较的元素（例如，字符串和整数） |
| IllegalArgumentException | （可选）如果发现数组元素的自然顺序违反了 Comparable 合约 |
parallelSort
public static <T extends Comparable<? super T>> void parallelSort(T[] a, int fromIndex, int toIndex)
根据其元素的 Comparable 对指定对象数组的指定范围进行升序排序。 要排序的范围从 index fromIndex（包括）扩展到 index toIndex（不包括）。 （如果fromIndex==toIndex，则要排序的范围为空。）该范围内的所有元素都必须实现Comparable接口。 此外，此范围内的所有元素必须相互可比较（即，e1.compareTo(e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。
这种排序保证是稳定的：相同的元素不会因为排序而重新排序。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 要排序的对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素（不包括）的索引 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex 或（可选）如果发现数组元素的自然顺序违反了 Comparable 约定 |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
| ClassCastException | 如果数组包含不可相互比较的元素（例如，字符串和整数）。 |
parallelSort
public static <T> void parallelSort(T[] a, Comparator<? super T> cmp)
根据指定比较器产生的顺序对指定的对象数组进行排序。 数组中的所有元素必须通过指定的比较器相互比较（即，c.compare(e1, e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。
这种排序保证是稳定的：相同的元素不会因为排序而重新排序。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 要排序的对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| cmp | 比较器来确定数组的顺序。 空值表示应该使用元素的 Comparable。 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ClassCastException | 如果数组包含使用指定比较器不能相互比较的元素 |
| IllegalArgumentException | （可选）如果发现比较器违反了比较器合同 |
parallelSort
public static <T> void parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)
根据指定比较器的顺序对指定对象数组的指定范围进行排序。 要排序的范围从 index fromIndex（包括）扩展到 index toIndex（不包括）。 （如果 fromIndex==toIndex，则要排序的范围为空。）范围内的所有元素必须通过指定的比较器相互比较（即 c.compare(e1, e2) 不得为任何元素 e1 抛出 ClassCastException 和 e2 在范围内）。
这种排序保证是稳定的：相同的元素不会因为排序而重新排序。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 要排序的对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素（不包括）的索引 |
| cmp | 比较器来确定数组的顺序。 空值表示应该使用元素的 Comparable。 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex 或（可选）如果发现数组元素的自然顺序违反了 Comparable 约定 |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
| ClassCastException | 如果数组包含不可相互比较的元素（例如，字符串和整数）。 |
sort
public static void sort(Object[] a)
根据其元素的 Comparable 对指定的对象数组进行升序排序。数组中的所有元素都必须实现 Comparable 接口。此外，数组中的所有元素必须相互可比较（即，e1.compareTo(e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。
这种排序保证是稳定的：相同的元素不会因为排序而重新排序。
实现说明：此实现是一种稳定的、自适应的、迭代的归并排序，当输入数组部分排序时，它需要远少于 n 次 lg(n) 的比较，同时在输入数组随机排序时提供传统归并排序的性能。如果输入数组接近排序，则实现需要大约 n 次比较。临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的 n/2 对象引用不等。
该实现在其输入数组中同等地利用升序和降序，并且可以在同一输入数组的不同部分利用升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。
该实现改编自 Tim Peters 的 Python 列表排序 (TimSort)。它使用了 Peter McIlroy 在 1993 年 1 月的第四届 ACM-SIAM 离散算法年度研讨会论文集上的“乐观排序和信息理论复杂性”中的技术。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ClassCastException | 如果数组包含不可相互比较的元素（例如，字符串和整数） |
| IllegalArgumentException | （可选）如果发现数组元素的自然顺序违反了 Comparable 合约 |
sort
public static void sort(Object[] a, int fromIndex, int toIndex)
根据其元素的 Comparable 对指定对象数组的指定范围进行升序排序。要排序的范围从 index fromIndex（包括）扩展到 index toIndex（不包括）。 （如果fromIndex==toIndex，则要排序的范围为空。）该范围内的所有元素都必须实现Comparable接口。此外，此范围内的所有元素必须相互可比较（即，e1.compareTo(e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。
这种排序保证是稳定的：相同的元素不会因为排序而重新排序。
实现说明：此实现是一种稳定的、自适应的、迭代的归并排序，当输入数组部分排序时，它需要远少于 n 次 lg(n) 的比较，同时在输入数组随机排序时提供传统归并排序的性能。如果输入数组接近排序，则实现需要大约 n 次比较。临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的 n/2 对象引用不等。
该实现在其输入数组中同等地利用升序和降序，并且可以在同一输入数组的不同部分利用升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。
该实现改编自 Tim Peters 的 Python 列表排序 (TimSort)。它使用了 Peter McIlroy 在 1993 年 1 月的第四届 ACM-SIAM 离散算法年度研讨会论文集上的“乐观排序和信息理论复杂性”中的技术。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素（不包括）的索引 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| 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) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。
这种排序保证是稳定的：相同的元素不会因为排序而重新排序。
实现说明：此实现是一种稳定的、自适应的、迭代的归并排序，当输入数组部分排序时，它需要远少于 n 次 lg(n) 的比较，同时在输入数组随机排序时提供传统归并排序的性能。如果输入数组接近排序，则实现需要大约 n 次比较。临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的 n/2 对象引用不等。
该实现在其输入数组中同等地利用升序和降序，并且可以在同一输入数组的不同部分利用升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。
该实现改编自 Tim Peters 的 Python 列表排序 (TimSort)。它使用了 Peter McIlroy 在 1993 年 1 月的第四届 ACM-SIAM 离散算法年度研讨会论文集上的“乐观排序和信息理论复杂性”中的技术。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 要排序的对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| c | 比较器来确定数组的顺序。 空值表示应该使用元素的 Comparable。 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ClassCastException | 如果数组包含使用指定比较器不能相互比较的元素 |
| IllegalArgumentException | （可选）如果发现比较器违反了比较器合同 |
sort
public static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
根据指定比较器的顺序对指定对象数组的指定范围进行排序。要排序的范围从 index fromIndex（包括）扩展到 index toIndex（不包括）。 （如果 fromIndex==toIndex，则要排序的范围为空。）范围内的所有元素必须通过指定的比较器相互比较（即 c.compare(e1, e2) 不得为任何元素 e1 抛出 ClassCastException和 e2 在范围内）。
这种排序保证是稳定的：相同的元素不会因为排序而重新排序。
实现说明：此实现是一种稳定的、自适应的、迭代的归并排序，当输入数组部分排序时，它需要远少于 n 次 lg(n) 的比较，同时在输入数组随机排序时提供传统归并排序的性能。如果输入数组接近排序，则实现需要大约 n 次比较。临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的 n/2 对象引用不等。
该实现在其输入数组中同等地利用升序和降序，并且可以在同一输入数组的不同部分利用升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。
该实现改编自 Tim Peters 的 Python 列表排序 (TimSort)。它使用了 Peter McIlroy 在 1993 年 1 月的第四届 ACM-SIAM 离散算法年度研讨会论文集上的“乐观排序和信息理论复杂性”中的技术。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 要排序的对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| a | 要排序的数组 |
| fromIndex | 要排序的第一个元素（包括）的索引 |
| toIndex | 要排序的最后一个元素（不包括）的索引 |
| c | 比较器来确定数组的顺序。 空值表示应该使用元素的 Comparable。 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ClassCastException | 如果数组包含使用指定比较器不能相互比较的元素。 |
| IllegalArgumentException | 如果 fromIndex > toIndex 或（可选）如果发现比较器违反了比较器合约 |
| 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 | 执行累积的无副作用的关联函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果指定的数组或函数为空 |
parallelPrefix
public static <T> void parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)
对数组的给定子范围执行 [parallelPrefix(java.lang.Object],java.util.function.BinaryOperator)。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 数组中对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| array | 数组 |
| fromIndex | 第一个元素的索引，包括 |
| toIndex | 最后一个元素的索引，不包含 |
| op | 执行累积的无副作用的关联函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > array.length |
| NullPointerException | 如果指定的数组或函数为空 |
parallelPrefix
public static void parallelPrefix(long[] array, LongBinaryOperator op)
使用提供的函数并行累积给定数组的每个元素。 例如，如果数组最初保存 [2, 1, 0, 3] 并且操作执行加法，则返回时数组保存 [2, 3, 3, 6]。 对于大型数组，并行前缀计算通常比顺序循环更有效。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，通过此方法就地修改 |
| op | 执行累积的无副作用的关联函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果指定的数组或函数为空 |
parallelPrefix
public static void parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)
对数组的给定子范围执行 [parallelPrefix(long],java.util.function.LongBinaryOperator)。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组 |
| fromIndex | 第一个元素的索引，包括 |
| toIndex | 最后一个元素的索引，不包含 |
| op | 执行累积的无副作用的关联函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > array.length |
| NullPointerException | 如果指定的数组或函数为空 |
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 | 执行累积的无副作用函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果指定的数组或函数为空 |
parallelPrefix
public static void parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)
对数组的给定子范围执行 [parallelPrefix(double],java.util.function.DoubleBinaryOperator)。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组 |
| fromIndex | 第一个元素的索引，包括 |
| toIndex | 最后一个元素的索引，不包含 |
| op | 执行累积的无副作用的关联函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > array.length |
| NullPointerException | 如果指定的数组或函数为空 |
parallelPrefix
public static void parallelPrefix(int[] array, IntBinaryOperator op)
使用提供的函数并行累积给定数组的每个元素。 例如，如果数组最初保存 [2, 1, 0, 3] 并且操作执行加法，则返回时数组保存 [2, 3, 3, 6]。 对于大型数组，并行前缀计算通常比顺序循环更有效。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，通过此方法就地修改 |
| op | 执行累积的无副作用的关联函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果指定的数组或函数为空 |
parallelPrefix
public static void parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)
对数组的给定子范围执行 [parallelPrefix(int],java.util.function.IntBinaryOperator)。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组 |
| fromIndex | 第一个元素的索引，包括 |
| toIndex | 最后一个元素的索引，不包含 |
| op | 执行累积的无副作用的关联函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > array.length |
| NullPointerException | 如果指定的数组或函数为空 |
binarySearch
public static int binarySearch(long[] a, long key)
使用二进制搜索算法在指定的 long 数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(long]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
binarySearch
public static int binarySearch(long[] a, int fromIndex, int toIndex, long key)
使用二进制搜索算法在指定的 long 数组的范围内搜索指定值。 在进行此调用之前，必须对范围进行排序（如通过 [sort(long],int,int) 方法）。 如果未排序，则结果未定义。 如果范围包含多个具有指定值的元素，则无法保证会找到哪一个。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| fromIndex | 要搜索的第一个元素（包括）的索引 |
| toIndex | 要搜索的最后一个元素（不包括）的索引 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
binarySearch
public static int binarySearch(int[] a, int key)
使用二进制搜索算法在指定的整数数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(int]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 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 | 要搜索的值 |
返回:
搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
binarySearch
public static int binarySearch(short[] a, short key)
使用二分搜索算法在指定的 short 数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(short]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
binarySearch
public static int binarySearch(short[] a, int fromIndex, int toIndex, short key)
使用二分搜索算法在指定的 short 数组的范围内搜索指定的值。 在进行此调用之前，必须对范围进行排序（如通过 [sort(short],int,int) 方法）。 如果未排序，则结果未定义。 如果范围包含多个具有指定值的元素，则无法保证会找到哪一个。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| fromIndex | 要搜索的第一个元素（包括）的索引 |
| toIndex | 要搜索的最后一个元素（不包括）的索引 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
binarySearch
public static int binarySearch(char[] a, char key)
使用二进制搜索算法在指定的字符数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(char]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 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 | 要搜索的值 |
返回:
搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
binarySearch
public static int binarySearch(byte[] a, byte key)
使用二进制搜索算法在指定的字节数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(byte]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 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 | 要搜索的值 |
返回:
搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
binarySearch
public static int binarySearch(double[] a, double key)
使用二进制搜索算法在指定的双精度数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(double]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。 此方法认为所有 NaN 值是等价和相等的。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
binarySearch
public static int binarySearch(double[] a, int fromIndex, int toIndex, double key)
使用二分搜索算法在指定的双精度数组范围内搜索指定值。 在进行此调用之前，必须对范围进行排序（如通过 [sort(double],int,int) 方法）。 如果未排序，则结果未定义。 如果范围包含多个具有指定值的元素，则无法保证会找到哪一个。 此方法认为所有 NaN 值是等价和相等的。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| fromIndex | 要搜索的第一个元素（包括）的索引 |
| toIndex | 要搜索的最后一个元素（不包括）的索引 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
binarySearch
public static int binarySearch(float[] a, float key)
使用二进制搜索算法在指定的浮点数数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(float]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。 此方法认为所有 NaN 值是等价和相等的。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
binarySearch
public static int binarySearch(float[] a, int fromIndex, int toIndex, float key)
使用二分搜索算法在指定浮点数数组的范围内搜索指定值。 在进行此调用之前，必须对范围进行排序（如通过 [sort(float],int,int) 方法）。 如果未排序，则结果未定义。 如果范围包含多个具有指定值的元素，则无法保证会找到哪一个。 此方法认为所有 NaN 值是等价和相等的。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| fromIndex | 要搜索的第一个元素（包括）的索引 |
| toIndex | 要搜索的最后一个元素（不包括）的索引 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
binarySearch
public static int binarySearch(Object[] a, Object key)
使用二分搜索算法在指定数组中搜索指定对象。 在进行此调用之前，必须根据其元素的 Comparable 对数组进行升序排序（如通过 [sort(java.lang.Object]) 方法）。 如果未排序，则结果未定义。 （如果数组包含不可相互比较的元素（例如，字符串和整数），则无法根据其元素的自然顺序对其进行排序，因此结果未定义。）如果数组包含多个等于指定对象的元素 , 不能保证会找到哪一个。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ClassCastException | 如果搜索键与数组的元素不可比较。 |
binarySearch
public static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
使用二分搜索算法在指定数组的范围内搜索指定对象。 在进行此调用之前，必须根据其元素的 Comparable 对范围进行升序排序（如通过 [sort(java.lang.Object],int,int) 方法）。 如果未排序，则结果未定义。 （如果范围包含不可相互比较的元素（例如，字符串和整数），则无法根据其元素的自然顺序对其进行排序，因此结果未定义。）如果范围包含多个等于指定对象的元素 , 不能保证会找到哪一个。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| fromIndex | 要搜索的第一个元素（包括）的索引 |
| toIndex | 要搜索的最后一个元素（不包括）的索引 |
| key | 要搜索的值 |
返回:
搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ClassCastException | 如果搜索键与指定范围内的数组元素不可比较。 |
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
binarySearch
public static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)
使用二分搜索算法在指定数组中搜索指定对象。 在进行此调用之前，必须根据指定的比较器（如通过 [sort(T], Comparator) 方法）对数组进行升序排序。 如果未排序，则结果未定义。 如果数组包含多个等于指定对象的元素，则无法保证会找到哪一个。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 数组中对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| a | 要搜索的数组 |
| key | 要搜索的值 |
| c | 排序数组的比较器。 空值表示应该使用元素的 Comparable。 |
返回:
搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| 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 | 排序数组的比较器。 空值表示应该使用元素的 Comparable。 |
返回:
搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ClassCastException | 如果范围包含使用指定比较器无法相互比较的元素，或者搜索键与使用此比较器的范围内的元素不可比较。 |
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
equals
public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 一个要测试是否相等的数组 |
| a2 | 要测试相等性的另一个数组 |
返回:
如果两个数组相等则为true
equals
public static boolean equals(int[] a, int[] a2)
如果两个指定的 int 数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 一个要测试是否相等的数组 |
| a2 | 要测试相等性的另一个数组 |
返回:
如果两个数组相等则为true
equals
public static boolean equals(short[] a, short[] a2)
如果两个指定的 short 数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 一个要测试是否相等的数组 |
| a2 | 要测试相等性的另一个数组 |
返回:
如果两个数组相等则为true
equals
public static boolean equals(char[] a, char[] a2)
如果两个指定的字符数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 一个要测试是否相等的数组 |
| a2 | 要测试相等性的另一个数组 |
返回:
如果两个数组相等则为true
equals
public static boolean equals(byte[] a, byte[] a2)
如果两个指定的字节数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 一个要测试是否相等的数组 |
| a2 | 要测试相等性的另一个数组 |
返回:
如果两个数组相等则为true
equals
public static boolean equals(boolean[] a, boolean[] a2)
如果两个指定的布尔值数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 一个要测试是否相等的数组 |
| a2 | 要测试相等性的另一个数组 |
返回:
如果两个数组相等则为true
equals
public static boolean equals(double[] a, double[] a2)
如果两个指定的双精度数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。
如果满足以下条件，则认为两个双精度 d1 和 d2 相等：
new Double(d1).equals(new Double(d2))（与 == 运算符不同，此方法认为 NaN 等于自身，并且 0.0d 不等于 -0.0d。）
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 一个要测试是否相等的数组 |
| a2 | 要测试相等性的另一个数组 |
返回:
如果两个数组相等则为true
equals
public static boolean equals(float[] a, float[] a2)
如果两个指定的浮点数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。
如果满足以下条件，则认为两个浮点 f1 和 f2 相等：
new Float(f1).equals(new Float(f2))（与 == 运算符不同，此方法认为 NaN 等于自身，并且 0.0f 不等于 -0.0f。）
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 一个要测试是否相等的数组 |
| a2 | 要测试相等性的另一个数组 |
返回:
如果两个数组相等则为true
equals
public static boolean equals(Object[] a, Object[] a2)
如果两个指定的 Objects 数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为这两个数组相等。 如果 (e1==null ? e2==null : e1.equals(e2))，则认为两个对象 e1 和 e2 相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 一个要测试是否相等的数组 |
| a2 | 要测试相等性的另一个数组 |
返回:
如果两个数组相等则为true
fill
public static void fill(long[] a, long val)
将指定的 long 值分配给指定的 long 数组的每个元素。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| val | 要存储在数组的所有元素中的值 |
fill
public static void fill(long[] a, int fromIndex, int toIndex, long val)
将指定的 long 值分配给指定 long 数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| fromIndex | 要填充指定值的第一个元素（包括）的索引 |
| toIndex | 要填充指定值的最后一个元素（不包括）的索引 |
| val | 要存储在数组的所有元素中的值 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| 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 数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| fromIndex | 要填充指定值的第一个元素（包括）的索引 |
| toIndex | 要填充指定值的最后一个元素（不包括）的索引 |
| val | 要存储在数组的所有元素中的值 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| 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 数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| fromIndex | 要填充指定值的第一个元素（包括）的索引 |
| toIndex | 要填充指定值的最后一个元素（不包括）的索引 |
| val | 要存储在数组的所有元素中的值 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
fill
public static void fill(char[] a, char val)
将指定的 char 值分配给指定的 char 数组的每个元素。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| val | 要存储在数组的所有元素中的值 |
fill
public static void fill(char[] a, int fromIndex, int toIndex, char val)
将指定的 char 值分配给指定字符数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| fromIndex | 要填充指定值的第一个元素（包括）的索引 |
| toIndex | 要填充指定值的最后一个元素（不包括）的索引 |
| val | 要存储在数组的所有元素中的值 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| 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)
将指定的字节值分配给指定字节数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| fromIndex | 要填充指定值的第一个元素（包括）的索引 |
| toIndex | 要填充指定值的最后一个元素（不包括）的索引 |
| val | 要存储在数组的所有元素中的值 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| 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)
将指定的布尔值分配给指定布尔数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| fromIndex | 要填充指定值的第一个元素（包括）的索引 |
| toIndex | 要填充指定值的最后一个元素（不包括）的索引 |
| val | 要存储在数组的所有元素中的值 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| 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 数组的指定范围内的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| fromIndex | 要填充指定值的第一个元素（包括）的索引 |
| toIndex | 要填充指定值的最后一个元素（不包括）的索引 |
| val | 要存储在数组的所有元素中的值 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
fill
public static void fill(float[] a, float val)
将指定的浮点值分配给指定浮点数组的每个元素。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| val | 要存储在数组的所有元素中的值 |
fill
public static void fill(float[] a, int fromIndex, int toIndex, float val)
将指定的浮点值分配给指定浮点数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| fromIndex | 要填充指定值的第一个元素（包括）的索引 |
| toIndex | 要填充指定值的最后一个元素（不包括）的索引 |
| val | 要存储在数组的所有元素中的值 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
fill
public static void fill(Object[] a, Object val)
将指定的 Object 引用分配给指定的 Objects 数组的每个元素。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| val | 要存储在数组的所有元素中的值 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayStoreException | 如果指定的值不是可以存储在指定数组中的运行时类型 |
fill
public static void fill(Object[] a, int fromIndex, int toIndex, Object val)
将指定的 Object 引用分配给指定的 Objects 数组的指定范围内的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要填充的数组 |
| fromIndex | 要填充指定值的第一个元素（包括）的索引 |
| toIndex | 要填充指定值的最后一个元素（不包括）的索引 |
| val | 要存储在数组的所有元素中的值 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果 fromIndex > toIndex |
| ArrayIndexOutOfBoundsException | 如果 fromIndex < 0 或 toIndex > a.length |
| ArrayStoreException | 如果指定的值不是可以存储在指定数组中的运行时类型 |
copyOf
public static <T> T[] copyOf(T[] original, int newLength)
复制指定的数组，截断或填充空值（如有必要），使副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含 null。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。 结果数组与原始数组的类完全相同。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 数组中对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| original | 要复制的数组 |
| newLength | 要返回的副本的长度 |
返回:
原始数组的副本，被截断或用空值填充以获得指定的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NegativeArraySizeException | 如果 newLength 为负 |
| NullPointerException | 如果 original 为空 |
copyOf
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)
复制指定的数组，截断或填充空值（如有必要），使副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含 null。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。 结果数组属于 newType 类。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| U | 原始数组中对象的类 |
| T | 返回数组中对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| original | 要复制的数组 |
| newLength | 要返回的副本的长度 |
| newType | 要返回的副本的类别 |
返回:
原始数组的副本，被截断或用空值填充以获得指定的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NegativeArraySizeException | 如果 newLength 为负 |
| NullPointerException | 如果 original 为空 |
| ArrayStoreException | 如果从原始复制的元素不是可以存储在类 newType 数组中的运行时类型 |
copyOf
public static byte[] copyOf(byte[] original, int newLength)
复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含 (byte)0。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要复制的数组 |
| newLength | 要返回的副本的长度 |
返回:
原始数组的副本，被截断或用零填充以获得指定的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NegativeArraySizeException | 如果 newLength 为负 |
| NullPointerException | 如果 original 为空 |
copyOf
public static short[] copyOf(short[] original, int newLength)
复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含（短）0。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要复制的数组 |
| newLength | 要返回的副本的长度 |
返回:
原始数组的副本，被截断或用零填充以获得指定的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NegativeArraySizeException | 如果 newLength 为负 |
| NullPointerException | 如果 original 为空 |
copyOf
public static int[] copyOf(int[] original, int newLength)
复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始数组中无效的任何索引，副本将包含 0。当且仅当指定长度大于原始数组的长度时，此类索引才会存在。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要复制的数组 |
| newLength | 要返回的副本的长度 |
返回:
原始数组的副本，被截断或用零填充以获得指定的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NegativeArraySizeException | 如果 newLength 为负 |
| NullPointerException | 如果 original 为空 |
copyOf
public static long[] copyOf(long[] original, int newLength)
复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含 0L。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要复制的数组 |
| newLength | 要返回的副本的长度 |
返回:
原始数组的副本，被截断或用零填充以获得指定的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NegativeArraySizeException | 如果 newLength 为负 |
| NullPointerException | 如果 original 为空 |
copyOf
public static char[] copyOf(char[] original, int newLength)
复制指定的数组，用空字符截断或填充（如有必要），使副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含“\u000”。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要复制的数组 |
| newLength | 要返回的副本的长度 |
返回:
原始数组的副本，被截断或用空字符填充以获得指定的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NegativeArraySizeException | 如果 newLength 为负 |
| NullPointerException | 如果 original 为空 |
copyOf
public static float[] copyOf(float[] original, int newLength)
复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但不是原始索引的任何索引，副本将包含 0f。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要复制的数组 |
| newLength | 要返回的副本的长度 |
返回:
原始数组的副本，被截断或用零填充以获得指定的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NegativeArraySizeException | 如果 newLength 为负 |
| NullPointerException | 如果 original 为空 |
copyOf
public static double[] copyOf(double[] original, int newLength)
复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但不是原始索引的任何索引，副本将包含 0d。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要复制的数组 |
| newLength | 要返回的副本的长度 |
返回:
原始数组的副本，被截断或用零填充以获得指定的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NegativeArraySizeException | 如果 newLength 为负 |
| NullPointerException | 如果 original 为空 |
copyOf
public static boolean[] copyOf(boolean[] original, int newLength)
复制指定的数组，用 false 截断或填充（如果需要），使副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含 false。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要复制的数组 |
| newLength | 要返回的副本的长度 |
返回:
原始数组的副本，被截断或填充假元素以获得指定的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NegativeArraySizeException | 如果 newLength 为负 |
| NullPointerException | 如果 original 为空 |
copyOfRange
public static <T> T[] copyOfRange(T[] original, int from, int to)
将指定数组的指定范围复制到新数组中。 范围 (from) 的初始索引必须介于零和 original.length 之间，包括两者。 original[from] 的值被放入副本的初始元素中（除非 from == original.length 或 from == to）。 原始数组中后续元素的值被放入副本中的后续元素中。 范围（to）的最终索引，必须大于或等于 from，可能大于 original.length，在这种情况下，null 放置在索引大于或等于 original 的副本的所有元素中。 长度 - 从。 返回数组的长度将是 to - from。
结果数组与原始数组的类完全相同。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 数组中对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| original | 要从中复制范围的数组 |
| from | 要复制的范围的初始索引，包括 |
| to | 要复制的范围的最终索引，独占。 （此索引可能位于数组之外。） |
返回:
包含原始数组中指定范围的新数组，截断或填充空值以获得所需的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 from < 0 或者 from > original.length |
| IllegalArgumentException | 如果 from > to |
| NullPointerException | 如果 original 为空 |
copyOfRange
public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)
将指定数组的指定范围复制到新数组中。 范围 (from) 的初始索引必须介于零和 original.length 之间，包括两者。 original[from] 的值被放入副本的初始元素中（除非 from == original.length 或 from == to）。 原始数组中后续元素的值被放入副本中的后续元素中。 范围（to）的最终索引，必须大于或等于 from，可能大于 original.length，在这种情况下，null 放置在索引大于或等于 original 的副本的所有元素中。 长度 - 从。 返回数组的长度将是 to - from。 结果数组属于 newType 类。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| U | 原始数组中对象的类 |
| T | 返回数组中对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| original | 要从中复制范围的数组 |
| from | 要复制的范围的初始索引，包括 |
| to | 要复制的范围的最终索引，独占。 （此索引可能位于数组之外。） |
| newType | 要返回的副本的类别 |
返回:
包含原始数组中指定范围的新数组，截断或填充空值以获得所需的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 from < 0 或 from > original.length |
| IllegalArgumentException | 如果 from > to |
| NullPointerException | 如果 original 为空 |
| ArrayStoreException | 如果从原始元素复制的元素不是可以存储在类 newType 数组中的运行时类型。 |
copyOfRange
public static byte[] copyOfRange(byte[] original, int from, int to)
将指定数组的指定范围复制到新数组中。 范围 (from) 的初始索引必须介于零和 original.length 之间，包括两者。 original[from] 的值被放入副本的初始元素中（除非 from == original.length 或 from == to）。 原始数组中后续元素的值被放入副本中的后续元素中。 范围（to）的最终索引，必须大于等于from，可能大于original.length，这种情况下（byte）0被放置在索引大于等于的副本的所有元素中 到 original.length - 从。 返回数组的长度将是 to - from。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要从中复制范围的数组 |
| from | 要复制的范围的初始索引，包括 |
| to | 要复制的范围的最终索引，独占。 （此索引可能位于数组之外。） |
返回:
包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 from < 0 或 from > original.length |
| IllegalArgumentException | 如果 from > to |
| NullPointerException | 如果 original 为空 |
copyOfRange
public static short[] copyOfRange(short[] original, int from, int to)
将指定数组的指定范围复制到新数组中。 范围 (from) 的初始索引必须介于零和 original.length 之间，包括两者。 original[from] 的值被放入副本的初始元素中（除非 from == original.length 或 from == to）。 原始数组中后续元素的值被放入副本中的后续元素中。 范围（to）的最终索引，必须大于或等于from，可能大于original.length，这种情况下（short）0被放置在索引大于或等于副本的所有元素中 到 original.length - 从。 返回数组的长度将是 to - from。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要从中复制范围的数组 |
| from | 要复制的范围的初始索引，包括 |
| to | 要复制的范围的最终索引，独占。 （此索引可能位于数组之外。） |
返回:
包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 from < 0 或 from > original.length |
| IllegalArgumentException | 如果 from > to |
| NullPointerException | 如果 original 为空 |
copyOfRange
public static int[] copyOfRange(int[] original, int from, int to)
将指定数组的指定范围复制到新数组中。 范围 (from) 的初始索引必须介于零和 original.length 之间，包括两者。 original[from] 的值被放入副本的初始元素中（除非 from == original.length 或 from == to）。 原始数组中后续元素的值被放入副本中的后续元素中。 范围（to）的最终索引，必须大于或等于from，可能大于original.length，在这种情况下，0被放置在索引大于或等于original的副本的所有元素中。 长度 - 从。 返回数组的长度将是 to - from。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要从中复制范围的数组 |
| from | 要复制的范围的初始索引，包括 |
| to | 要复制的范围的最终索引，独占。 （此索引可能位于数组之外。） |
返回:
包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 from < 0 或 from > original.length |
| IllegalArgumentException | 如果 from > to |
| NullPointerException | 如果 original 为空 |
copyOfRange
public static long[] copyOfRange(long[] original, int from, int to)
将指定数组的指定范围复制到新数组中。 范围 (from) 的初始索引必须介于零和 original.length 之间，包括两者。 original[from] 的值被放入副本的初始元素中（除非 from == original.length 或 from == to）。 原始数组中后续元素的值被放入副本中的后续元素中。 范围（to）的最终索引，必须大于或等于from，可能大于original.length，这种情况下，0L被放置在索引大于或等于original的副本的所有元素中。 长度 - 从。 返回数组的长度将是 to - from。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要从中复制范围的数组 |
| from | 要复制的范围的初始索引，包括 |
| to | 要复制的范围的最终索引，独占。 （此索引可能位于数组之外。） |
返回:
包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 from < 0 或 from > original.length |
| IllegalArgumentException | 如果 from > to |
| NullPointerException | 如果 original 为空 |
copyOfRange
public static char[] copyOfRange(char[] original, int from, int to)
将指定数组的指定范围复制到新数组中。 范围 (from) 的初始索引必须介于零和 original.length 之间，包括两者。 original[from] 的值被放入副本的初始元素中（除非 from == original.length 或 from == to）。 原始数组中后续元素的值被放入副本中的后续元素中。 范围（to）的最终索引，必须大于等于from，可能大于original.length，这种情况下'\u000'被放置在所有索引大于等于的副本的元素中 到 original.length - 从。 返回数组的长度将是 to - from。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要从中复制范围的数组 |
| from | 要复制的范围的初始索引，包括 |
| to | 要复制的范围的最终索引，独占。 （此索引可能位于数组之外。） |
返回:
包含原始数组中指定范围的新数组，截断或填充空字符以获得所需的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 from < 0 或 from > original.length |
| IllegalArgumentException | 如果 from > to |
| NullPointerException | 如果 original 为空 |
copyOfRange
public static float[] copyOfRange(float[] original, int from, int to)
将指定数组的指定范围复制到新数组中。 范围 (from) 的初始索引必须介于零和 original.length 之间，包括两者。 original[from] 的值被放入副本的初始元素中（除非 from == original.length 或 from == to）。 原始数组中后续元素的值被放入副本中的后续元素中。 范围（to）的最终索引，必须大于或等于from，可能大于original.length，在这种情况下，0f被放置在索引大于或等于original的副本的所有元素中。 长度 - 从。 返回数组的长度将是 to - from。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要从中复制范围的数组 |
| from | 要复制的范围的初始索引，包括 |
| to | 要复制的范围的最终索引，独占。 （此索引可能位于数组之外。） |
返回:
包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 from < 0 或 from > original.length |
| IllegalArgumentException | 如果 from > to |
| NullPointerException | 如果 original 为空 |
copyOfRange
public static double[] copyOfRange(double[] original, int from, int to)
将指定数组的指定范围复制到新数组中。 范围 (from) 的初始索引必须介于零和 original.length 之间，包括两者。 original[from] 的值被放入副本的初始元素中（除非 from == original.length 或 from == to）。 原始数组中后续元素的值被放入副本中的后续元素中。 范围（to）的最终索引，必须大于或等于from，可能大于original.length，在这种情况下，0d被放置在索引大于或等于original的副本的所有元素中。 长度 - 从。 返回数组的长度将是 to - from。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要从中复制范围的数组 |
| from | 要复制的范围的初始索引，包括 |
| to | 要复制的范围的最终索引，独占。 （此索引可能位于数组之外。） |
返回:
包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 from < 0 或 from > original.length |
| IllegalArgumentException | 如果 from > to |
| NullPointerException | 如果 original 为空 |
copyOfRange
public static boolean[] copyOfRange(boolean[] original, int from, int to)
将指定数组的指定范围复制到新数组中。 范围 (from) 的初始索引必须介于零和 original.length 之间，包括两者。 original[from] 的值被放入副本的初始元素中（除非 from == original.length 或 from == to）。 原始数组中后续元素的值被放入副本中的后续元素中。 范围（to）的最终索引，必须大于或等于from，可能大于original.length，在这种情况下，false 被放置在索引大于或等于original 的副本的所有元素中。 长度 - 从。 返回数组的长度将是 to - from。
参数：
| 参数名称 | 参数描述 |
|---|---|
| original | 要从中复制范围的数组 |
| from | 要复制的范围的初始索引，包括 |
| to | 要复制的范围的最终索引，独占。 （此索引可能位于数组之外。） |
返回:
包含原始数组中指定范围的新数组，截断或填充错误元素以获得所需的长度
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 from < 0 或 from > original.length |
| IllegalArgumentException | 如果 from > to |
| NullPointerException | 如果 original 为空 |
asList
@SafeVarargs public static <T> List<T> asList(T... a)
返回由指定数组支持的固定大小的列表。 （将返回的列表“写入”到数组的更改。）此方法充当基于数组和基于集合的 API 之间的桥梁，与 Collection#toArray 结合使用。 返回的列表是可序列化的并实现了 RandomAccess。
此方法还提供了一种方便的方法来创建一个固定大小的列表，该列表已初始化为包含多个元素：
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly"); 类型参数:
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 数组中对象的类 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| a | 将支持列表的数组 |
返回:
指定数组的列表视图
hashCode
public static int hashCode(long[] a)
根据指定数组的内容返回哈希码。 对于任意两个长数组 a 和 b 使得 Arrays.equals(a, b)，Arrays.hashCode(a) == Arrays.hashCode(b) 也是如此。
此方法返回的值与通过在 List 上调用 List#hashCode() 方法获得的值相同，该 List 包含以相同顺序表示 a 的元素的 Long 实例序列。 如果 a 为 null，则此方法返回 0。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要计算其哈希值的数组 |
返回:
一个基于内容的哈希码
hashCode
public static int hashCode(int[] a)
根据指定数组的内容返回哈希码。 对于任意两个非空 int 数组 a 和 b 使得 Arrays.equals(a, b)，Arrays.hashCode(a) == Arrays.hashCode(b) 也是如此。
此方法返回的值与通过在 List 上调用 List#hashCode() 方法获得的值相同，该 List 包含以相同顺序表示 a 的元素的 Integer 实例序列。 如果 a 为 null，则此方法返回 0。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要计算其哈希值的数组 |
返回:
一个基于内容的哈希码
hashCode
public static int hashCode(short[] a)
根据指定数组的内容返回哈希码。 对于任意两个短数组 a 和 b 使得 Arrays.equals(a, b)，Arrays.hashCode(a) == Arrays.hashCode(b) 也是如此。
此方法返回的值与通过在 List 上调用 List#hashCode() 方法获得的值相同，该 List 包含以相同顺序表示 a 的元素的一系列 Short 实例。 如果 a 为 null，则此方法返回 0。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要计算其哈希值的数组 |
返回:
一个基于内容的哈希码
hashCode
public static int hashCode(char[] a)
根据指定数组的内容返回哈希码。 对于任意两个 char 数组 a 和 b 使得 Arrays.equals(a, b)，Arrays.hashCode(a) == Arrays.hashCode(b) 也是如此。
此方法返回的值与通过在 List 上调用 List#hashCode() 方法获得的值相同，该 List 包含以相同顺序表示 a 的元素的 Character 实例序列。 如果 a 为 null，则此方法返回 0。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要计算其哈希值的数组 |
返回:
一个基于内容的哈希码
hashCode
public static int hashCode(byte[] a)
根据指定数组的内容返回哈希码。 对于任意两个字节数组 a 和 b 使得 Arrays.equals(a, b)，Arrays.hashCode(a) == Arrays.hashCode(b) 也是如此。
此方法返回的值与通过在 List 上调用 List#hashCode() 方法获得的值相同，该 List 包含以相同顺序表示 a 的元素的 Byte 实例序列。 如果 a 为 null，则此方法返回 0。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要计算其哈希值的数组 |
返回:
一个基于内容的哈希码
hashCode
public static int hashCode(boolean[] a)
根据指定数组的内容返回哈希码。 对于任何两个布尔数组 a 和 b 使得 Arrays.equals(a, b)，Arrays.hashCode(a) == Arrays.hashCode(b) 也是如此。
此方法返回的值与通过在 List 上调用 List#hashCode() 方法获得的值相同，该 List 包含以相同顺序表示 a 元素的布尔实例序列。 如果 a 为 null，则此方法返回 0。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要计算其哈希值的数组 |
返回:
一个基于内容的哈希码
hashCode
public static int hashCode(float[] a)
根据指定数组的内容返回哈希码。 对于任意两个浮点数组 a 和 b 使得 Arrays.equals(a, b)，Arrays.hashCode(a) == Arrays.hashCode(b) 也是如此。
此方法返回的值与通过在 List 上调用 List#hashCode() 方法获得的值相同，该 List 包含以相同顺序表示 a 的元素的 Float 实例序列。 如果 a 为 null，则此方法返回 0。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要计算其哈希值的数组 |
返回:
一个基于内容的哈希码
hashCode
public static int hashCode(double[] a)
根据指定数组的内容返回哈希码。 对于任何两个使 Arrays.equals(a, b) 的双精度数组 a 和 b，Arrays.hashCode(a) == Arrays.hashCode(b) 也是如此。
此方法返回的值与通过在 List 上调用 List#hashCode() 方法获得的值相同，该 List 包含以相同顺序表示 a 的元素的 Double 实例序列。 如果 a 为 null，则此方法返回 0。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要计算其哈希值的数组 |
返回:
一个基于内容的哈希码
hashCode
public static int hashCode(Object[] a)
根据指定数组的内容返回哈希码。 如果数组包含其他数组作为元素，则哈希码基于它们的身份而不是它们的内容。 因此，可以直接或间接通过一个或多个级别的数组对包含自身作为元素的数组调用此方法。
对于任意两个数组 a 和 b 使得 Arrays.equals(a, b)，Arrays.hashCode(a) == Arrays.hashCode(b) 也是如此。
此方法返回的值等于 Arrays.asList(a).hashCode() 将返回的值，除非 a 为 null，在这种情况下返回 0。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要计算其基于内容的哈希码的数组 |
返回:
一个基于内容的哈希码
deepHashCode
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 | 要计算其基于深度内容的哈希码的数组 |
返回:
一个基于深度内容的哈希码
deepEquals
public static boolean deepEquals(Object[] a1, Object[] a2)
如果两个指定的数组彼此深度相等，则返回 true。 与 equals(java.lang.Object[],java.lang.Object[]) 方法不同，此方法适用于任意深度的嵌套数组。
如果两个数组引用都为空，或者它们引用的数组包含相同数量的元素并且两个数组中所有对应的元素对都非常相等，则认为两个数组引用是深度相等的。
如果满足以下任一条件，则两个可能为 null 的元素 e1 和 e2 完全相等：
- e1 和 e2 都是对象引用类型的数组，Arrays.deepEquals(e1, e2) 将返回 true
- e1 和 e2 是相同原始类型的数组，并且 Arrays.equals(e1, e2) 的适当重载将返回 true。
- e1 == e2
- e1.equals(e2) 将返回 true。
请注意，此定义允许任何深度的空元素。
如果任一指定的数组直接或通过一个或多个数组级别间接将自身包含为元素，则此方法的行为是未定义的。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a1 | 一个要测试是否相等的数组 |
| a2 | 要测试相等性的另一个数组 |
返回:
如果两个数组相等则为true
toString
public static String toString(long[] a)
返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 ("[]") 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(long) 将元素转换为字符串。 如果 a 为空，则返回“空”。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要返回其字符串表示形式的数组 |
返回:
a 的字符串表示
toString
public static String toString(int[] a)
返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 ("[]") 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(int) 将元素转换为字符串。 如果 a 为空，则返回“空”。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要返回其字符串表示形式的数组 |
返回:
a 的字符串表示
toString
public static String toString(short[] a)
返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 ("[]") 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(short) 将元素转换为字符串。 如果 a 为空，则返回“空”。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要返回其字符串表示形式的数组 |
返回:
a 的字符串表示
toString
public static String toString(char[] a)
返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 ("[]") 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(char) 将元素转换为字符串。 如果 a 为空，则返回“空”。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要返回其字符串表示形式的数组 |
返回:
a 的字符串表示
toString
public static String toString(byte[] a)
返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 ("[]") 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(byte) 将元素转换为字符串。 如果 a 为空，则返回“空”。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要返回其字符串表示形式的数组 |
返回:
a 的字符串表示
toString
public static String toString(boolean[] a)
返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 ("[]") 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(boolean) 将元素转换为字符串。 如果 a 为空，则返回“空”。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要返回其字符串表示形式的数组 |
返回:
a 的字符串表示
toString
public static String toString(float[] a)
返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 ("[]") 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(float) 将元素转换为字符串。 如果 a 为空，则返回“空”。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要返回其字符串表示形式的数组 |
返回:
a 的字符串表示
toString
public static String toString(double[] a)
返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 ("[]") 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(double) 将元素转换为字符串。 如果 a 为空，则返回“空”。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要返回其字符串表示形式的数组 |
返回:
a 的字符串表示
toString
public static String toString(Object[] a)
返回指定数组内容的字符串表示形式。 如果数组包含其他数组作为元素，它们会通过继承自 Object 的 Object#toString 方法转换为字符串，该方法描述的是它们的标识而不是它们的内容。
此方法返回的值等于 Arrays.asList(a).toString() 将返回的值，除非 a 为 null，在这种情况下返回“null”。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要返回其字符串表示形式的数组 |
返回:
a 的字符串表示
deepToString
public static String deepToString(Object[] a)
返回指定数组的“深层内容”的字符串表示形式。如果数组包含其他数组作为元素，则字符串表示包含它们的内容等等。此方法设计用于将多维数组转换为字符串。
字符串表示由数组元素的列表组成，括在方括号 ("[]") 中。相邻元素由字符“,”（逗号后跟一个空格）分隔。元素通过 String.valueOf(Object) 转换为字符串，除非它们本身是数组。
如果元素 e 是原始类型的数组，则通过调用 Arrays.toString(e) 的适当重载将其转换为字符串。如果元素 e 是引用类型的数组，则通过递归调用此方法将其转换为字符串。
为避免无限递归，如果指定数组包含自身作为元素，或者包含通过一层或多层数组间接引用自身，则将自引用转换为字符串“[...]”。例如，仅包含对其自身的引用的数组将呈现为“[[...]]”。
如果指定的数组为 null，则此方法返回“null”。
参数：
| 参数名称 | 参数描述 |
|---|---|
| a | 要返回其字符串表示形式的数组 |
返回:
a 的字符串表示
setAll
public static <T> void setAll(T[] array, IntFunction<? extends T> generator)
设置指定数组的所有元素，使用提供的生成器函数计算每个元素。
如果生成器函数抛出异常，则将其转发给调用者，并且数组处于不确定状态。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 数组元素的类型 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| array | 要初始化的数组 |
| generator | 接受索引并为该位置生成所需值的函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果 generator 为空 |
parallelSetAll
public static <T> void parallelSetAll(T[] array, IntFunction<? extends T> generator)
使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。
如果生成器函数抛出异常，则从 parallelSetAll 中抛出未经检查的异常，并且数组处于不确定状态。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 数组元素的类型 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| array | 要初始化的数组 |
| generator | 接受索引并为该位置生成所需值的函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果 generator 为空 |
setAll
public static void setAll(int[] array, IntUnaryOperator generator)
设置指定数组的所有元素，使用提供的生成器函数计算每个元素。
如果生成器函数抛出异常，则将其转发给调用者，并且数组处于不确定状态。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 要初始化的数组 |
| generator | 接受索引并为该位置生成所需值的函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果 generator 为空 |
parallelSetAll
public static void parallelSetAll(int[] array, IntUnaryOperator generator)
使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。
如果生成器函数抛出异常，则从 parallelSetAll 中抛出未经检查的异常，并且数组处于不确定状态。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 要初始化的数组 |
| generator | 接受索引并为该位置生成所需值的函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果 generator 为空 |
setAll
public static void setAll(long[] array, IntToLongFunction generator)
设置指定数组的所有元素，使用提供的生成器函数计算每个元素。
如果生成器函数抛出异常，则将其转发给调用者，并且数组处于不确定状态。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 要初始化的数组 |
| generator | 接受索引并为该位置生成所需值的函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果 generator 为空 |
parallelSetAll
public static void parallelSetAll(long[] array, IntToLongFunction generator)
使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。
如果生成器函数抛出异常，则从 parallelSetAll 中抛出未经检查的异常，并且数组处于不确定状态。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 要初始化的数组 |
| generator | 接受索引并为该位置生成所需值的函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果 generator 为空 |
setAll
public static void setAll(double[] array, IntToDoubleFunction generator)
设置指定数组的所有元素，使用提供的生成器函数计算每个元素。
如果生成器函数抛出异常，则将其转发给调用者，并且数组处于不确定状态。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 要初始化的数组 |
| generator | 接受索引并为该位置生成所需值的函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果 generator 为空 |
parallelSetAll
public static void parallelSetAll(double[] array, IntToDoubleFunction generator)
使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。
如果生成器函数抛出异常，则从 parallelSetAll 中抛出未经检查的异常，并且数组处于不确定状态。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 要初始化的数组 |
| generator | 接受索引并为该位置生成所需值的函数 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果 generator 为空 |
spliterator
public static <T> Spliterator<T> spliterator(T[] array)
返回一个涵盖所有指定数组的 Spliterator。
spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 元素类型 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假定在使用期间未修改 |
返回:
数组元素的拆分器
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 | 紧接着要覆盖的最后一个索引的索引 |
返回:
数组元素的拆分器
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小 |
spliterator
public static Spliterator.OfInt spliterator(int[] array)
返回一个 Spliterator.OfInt 覆盖所有指定的数组。
spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假定在使用期间未修改 |
返回:
数组元素的拆分器
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 | 紧接着要覆盖的最后一个索引的索引 |
返回:
数组元素的拆分器
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小 |
spliterator
public static Spliterator.OfLong spliterator(long[] array)
返回一个 Spliterator.OfLong 覆盖所有指定的数组。
spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假定在使用期间未修改 |
返回:
数组元素的拆分器
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 | 紧接着要覆盖的最后一个索引的索引 |
返回:
数组元素的拆分器
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小 |
spliterator
public static Spliterator.OfDouble spliterator(double[] array)
返回一个 Spliterator.OfDouble 覆盖所有指定的数组。
spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假定在使用期间未修改 |
返回:
数组元素的拆分器
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 | 紧接着要覆盖的最后一个索引的索引 |
返回:
数组元素的拆分器
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小 |
stream
public static <T> Stream<T> stream(T[] array)
返回以指定数组为源的顺序流。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 数组元素的类型 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假设在使用过程中未修改 |
返回:
数组的 Stream
stream
public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive)
返回以指定数组的指定范围作为源的顺序流。
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 数组元素的类型 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假定在使用期间未修改 |
| startInclusive | 第一个涵盖的索引，包括在内 |
| endExclusive | 紧接着要覆盖的最后一个索引的索引 |
返回:
数组范围的流
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小 |
stream
public static IntStream stream(int[] array)
返回以指定数组作为源的顺序 IntStream。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假定在使用期间未修改 |
返回:
数组的 IntStream
stream
public static IntStream stream(int[] array, int startInclusive, int endExclusive)
返回以指定数组的指定范围作为源的顺序 IntStream。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假定在使用期间未修改 |
| startInclusive | 第一个涵盖的索引，包括在内 |
| endExclusive | 紧接着要覆盖的最后一个索引的索引 |
返回:
数组范围的 IntStream
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小 |
stream
public static LongStream stream(long[] array)
返回以指定数组为源的顺序 LongStream。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假定在使用期间未修改 |
返回:
数组的 LongStream
stream
public static LongStream stream(long[] array, int startInclusive, int endExclusive)
返回以指定数组的指定范围作为源的顺序 LongStream。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假定在使用期间未修改 |
| startInclusive | 第一个涵盖的索引，包括在内 |
| endExclusive | 紧接着要覆盖的最后一个索引的索引 |
返回:
数组范围的 LongStream
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小 |
stream
public static DoubleStream stream(double[] array)
返回以指定数组为源的顺序 DoubleStream。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假定在使用期间未修改 |
返回:
数组的 DoubleStream
stream
public static DoubleStream stream(double[] array, int startInclusive, int endExclusive)
返回以指定数组的指定范围作为源的顺序 DoubleStream。
参数：
| 参数名称 | 参数描述 |
|---|---|
| array | 数组，假定在使用期间未修改 |
| startInclusive | 第一个涵盖的索引，包括在内 |
| endExclusive | 紧接着要覆盖的最后一个索引的索引 |
返回:
数组范围的 DoubleStream
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果 startInclusive 为负，则 endExclusive 小于 startInclusive，或者 endExclusive 大于数组大小 |