鸿蒙OS Arrays

Arrays

java.lang.Object

|—java.util.Arrays

public class Arrays
extends Object

此类包含用于操作数组（例如排序和搜索）的各种方法。 此类还包含一个允许将数组视为列表的静态工厂。

如果指定的数组引用为空，则此类中的方法都会抛出 NullPointerException，除非另有说明。

此类中包含的方法的文档包括实现的简要说明。 此类描述应被视为实现说明，而不是规范的一部分。 只要遵守规范本身，实现者应该可以随意替换其他算法。 （例如，sort(Object[]) 使用的算法不必是 MergeSort，但它必须是稳定的。）

此类是 Java 集合框架的成员。

方法总结

方法详情

sort

public static void sort(int[] a)

将指定的数组按数字升序排序。

实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

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)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

Throws:

sort

public static void sort(long[] a)

将指定的数组按数字升序排序。

实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

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)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

Throws:

sort

public static void sort(short[] a)

将指定的数组按数字升序排序。

实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

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)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

Throws:

sort

public static void sort(char[] a)

将指定的数组按数字升序排序。

实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

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)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

Throws:

sort

public static void sort(byte[] a)

将指定的数组按数字升序排序。

实施说明：排序算法是 Vladimir Yaroslavskiy、Jon Bentley 和 Joshua Bloch 的 Dual-Pivot Quicksort。 该算法在许多数据集上提供 O(n log(n)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

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)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

Throws:

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)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

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)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

Throws:

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)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

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)) 性能，导致其他快速排序降低到二次性能，并且通常比传统的（单轴）快速排序实现更快。

参数：

Throws:

parallelSort

public static void parallelSort(byte[] a)

将指定的数组按数字升序排序。

参数：

parallelSort

public static void parallelSort(byte[] a, int fromIndex, int toIndex)

将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。

参数：

Throws:

parallelSort

public static void parallelSort(char[] a)

将指定的数组按数字升序排序。

参数：

parallelSort

public static void parallelSort(char[] a, int fromIndex, int toIndex)

将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。

参数：

Throws:

parallelSort

public static void parallelSort(short[] a)

将指定的数组按数字升序排序。

参数：

parallelSort

public static void parallelSort(short[] a, int fromIndex, int toIndex)

将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。

参数：

Throws:

parallelSort

public static void parallelSort(int[] a)

将指定的数组按数字升序排序。

参数：

parallelSort

public static void parallelSort(int[] a, int fromIndex, int toIndex)

将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。

参数：

Throws:

parallelSort

public static void parallelSort(long[] a)

将指定的数组按数字升序排序。

参数：

parallelSort

public static void parallelSort(long[] a, int fromIndex, int toIndex)

将数组的指定范围按数字升序排序。 要排序的范围从索引 fromIndex（含）延伸到索引 toIndex（不含）。 如果 fromIndex == toIndex，则要排序的范围为空。

参数：

Throws:

parallelSort

public static void parallelSort(float[] a)

将指定的数组按数字升序排序。

< 关系不提供所有浮点值的总顺序：-0.0f == 0.0f 为真，并且 Float.NaN 值比较不小于、大于或等于任何值，甚至它本身。 此方法使用 Float#compareTo 方法施加的总顺序：-0.0f 被视为小于值 0.0f，Float.NaN 被视为大于任何其他值，并且所有 Float.NaN 值被视为相等。

参数：

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 值被视为相等。

参数：

Throws:

parallelSort

public static void parallelSort(double[] a)

将指定的数组按数字升序排序。

< 关系不提供所有双精度值的总顺序：-0.0d == 0.0d 为真，并且 Double.NaN 值比较不小于、大于或等于任何值，甚至它本身。 此方法使用 Double#compareTo 方法施加的总顺序：-0.0d 被视为小于值 0.0d，Double.NaN 被视为大于任何其他值，并且所有 Double.NaN 值被视为相等。

参数：

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 值被视为相等。

参数：

Throws:

parallelSort

public static <T extends Comparable<? super T>> void parallelSort(T[] a)

根据其元素的 Comparable 对指定的对象数组进行升序排序。 数组中的所有元素都必须实现 Comparable 接口。 此外，数组中的所有元素必须相互可比较（即，e1.compareTo(e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。

这种排序保证是稳定的：相同的元素不会因为排序而重新排序。

类型参数：

参数:

Throws:

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）。

这种排序保证是稳定的：相同的元素不会因为排序而重新排序。

类型参数：

参数:

Throws:

parallelSort

public static <T> void parallelSort(T[] a, Comparator<? super T> cmp)

根据指定比较器产生的顺序对指定的对象数组进行排序。 数组中的所有元素必须通过指定的比较器相互比较（即，c.compare(e1, e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。

这种排序保证是稳定的：相同的元素不会因为排序而重新排序。

类型参数：

参数:

Throws:

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 在范围内）。

这种排序保证是稳定的：相同的元素不会因为排序而重新排序。

类型参数：

参数:

Throws:

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 离散算法年度研讨会论文集上的“乐观排序和信息理论复杂性”中的技术。

参数：

Throws:

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 离散算法年度研讨会论文集上的“乐观排序和信息理论复杂性”中的技术。

参数：

Throws:

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 离散算法年度研讨会论文集上的“乐观排序和信息理论复杂性”中的技术。

类型参数：

参数:

Throws:

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 离散算法年度研讨会论文集上的“乐观排序和信息理论复杂性”中的技术。

类型参数：

参数:

Throws:

parallelPrefix

public static <T> void parallelPrefix(T[] array, BinaryOperator<T> op)

使用提供的函数并行累积给定数组的每个元素。 例如，如果数组最初保存 [2, 1, 0, 3] 并且操作执行加法，则返回时数组保存 [2, 3, 3, 6]。 对于大型数组，并行前缀计算通常比顺序循环更有效。

类型参数：

参数:

Throws:

parallelPrefix

public static <T> void parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)

对数组的给定子范围执行 [parallelPrefix(java.lang.Object],java.util.function.BinaryOperator)。

类型参数：

参数:

Throws:

parallelPrefix

public static void parallelPrefix(long[] array, LongBinaryOperator op)

使用提供的函数并行累积给定数组的每个元素。 例如，如果数组最初保存 [2, 1, 0, 3] 并且操作执行加法，则返回时数组保存 [2, 3, 3, 6]。 对于大型数组，并行前缀计算通常比顺序循环更有效。

参数：

Throws:

parallelPrefix

public static void parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)

对数组的给定子范围执行 [parallelPrefix(long],java.util.function.LongBinaryOperator)。

参数：

Throws:

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]。 对于大型数组，并行前缀计算通常比顺序循环更有效。

因为浮点运算可能不是严格关联的，所以返回的结果可能与按顺序执行运算时获得的值不同。

参数：

Throws:

parallelPrefix

public static void parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)

对数组的给定子范围执行 [parallelPrefix(double],java.util.function.DoubleBinaryOperator)。

参数：

Throws:

parallelPrefix

public static void parallelPrefix(int[] array, IntBinaryOperator op)

使用提供的函数并行累积给定数组的每个元素。 例如，如果数组最初保存 [2, 1, 0, 3] 并且操作执行加法，则返回时数组保存 [2, 3, 3, 6]。 对于大型数组，并行前缀计算通常比顺序循环更有效。

参数：

Throws:

parallelPrefix

public static void parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)

对数组的给定子范围执行 [parallelPrefix(int],java.util.function.IntBinaryOperator)。

参数：

Throws:

binarySearch

public static int binarySearch(long[] a, long key)

使用二进制搜索算法在指定的 long 数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(long]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

binarySearch

public static int binarySearch(long[] a, int fromIndex, int toIndex, long key)

使用二进制搜索算法在指定的 long 数组的范围内搜索指定值。 在进行此调用之前，必须对范围进行排序（如通过 [sort(long],int,int) 方法）。 如果未排序，则结果未定义。 如果范围包含多个具有指定值的元素，则无法保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

binarySearch

public static int binarySearch(int[] a, int key)

使用二进制搜索算法在指定的整数数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(int]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

binarySearch

public static int binarySearch(int[] a, int fromIndex, int toIndex, int key)

使用二进制搜索算法在指定整数数组的范围内搜索指定值。 在进行此调用之前，必须对范围进行排序（如通过 [sort(int],int,int) 方法）。 如果未排序，则结果未定义。 如果范围包含多个具有指定值的元素，则无法保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

binarySearch

public static int binarySearch(short[] a, short key)

使用二分搜索算法在指定的 short 数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(short]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

binarySearch

public static int binarySearch(short[] a, int fromIndex, int toIndex, short key)

使用二分搜索算法在指定的 short 数组的范围内搜索指定的值。 在进行此调用之前，必须对范围进行排序（如通过 [sort(short],int,int) 方法）。 如果未排序，则结果未定义。 如果范围包含多个具有指定值的元素，则无法保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

binarySearch

public static int binarySearch(char[] a, char key)

使用二进制搜索算法在指定的字符数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(char]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

binarySearch

public static int binarySearch(char[] a, int fromIndex, int toIndex, char key)

使用二进制搜索算法在指定字符数组的范围内搜索指定值。 在进行此调用之前，必须对范围进行排序（如通过 [sort(char],int,int) 方法）。 如果未排序，则结果未定义。 如果范围包含多个具有指定值的元素，则无法保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

binarySearch

public static int binarySearch(byte[] a, byte key)

使用二进制搜索算法在指定的字节数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(byte]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

binarySearch

public static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key)

使用二进制搜索算法在指定字节数组的范围内搜索指定值。 在进行此调用之前，必须对范围进行排序（如通过 [sort(byte],int,int) 方法）。 如果未排序，则结果未定义。 如果范围包含多个具有指定值的元素，则无法保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

binarySearch

public static int binarySearch(double[] a, double key)

使用二进制搜索算法在指定的双精度数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(double]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。 此方法认为所有 NaN 值是等价和相等的。

参数：

返回:

搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

binarySearch

public static int binarySearch(double[] a, int fromIndex, int toIndex, double key)

使用二分搜索算法在指定的双精度数组范围内搜索指定值。 在进行此调用之前，必须对范围进行排序（如通过 [sort(double],int,int) 方法）。 如果未排序，则结果未定义。 如果范围包含多个具有指定值的元素，则无法保证会找到哪一个。 此方法认为所有 NaN 值是等价和相等的。

参数：

返回:

搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

binarySearch

public static int binarySearch(float[] a, float key)

使用二进制搜索算法在指定的浮点数数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如通过 [sort(float]) 方法）。 如果未排序，则结果未定义。 如果数组包含多个具有指定值的元素，则无法保证会找到哪一个。 此方法认为所有 NaN 值是等价和相等的。

参数：

返回:

搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

binarySearch

public static int binarySearch(float[] a, int fromIndex, int toIndex, float key)

使用二分搜索算法在指定浮点数数组的范围内搜索指定值。 在进行此调用之前，必须对范围进行排序（如通过 [sort(float],int,int) 方法）。 如果未排序，则结果未定义。 如果范围包含多个具有指定值的元素，则无法保证会找到哪一个。 此方法认为所有 NaN 值是等价和相等的。

参数：

返回:

搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

binarySearch

public static int binarySearch(Object[] a, Object key)

使用二分搜索算法在指定数组中搜索指定对象。 在进行此调用之前，必须根据其元素的 Comparable 对数组进行升序排序（如通过 [sort(java.lang.Object]) 方法）。 如果未排序，则结果未定义。 （如果数组包含不可相互比较的元素（例如，字符串和整数），则无法根据其元素的自然顺序对其进行排序，因此结果未定义。）如果数组包含多个等于指定对象的元素 , 不能保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

binarySearch

public static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)

使用二分搜索算法在指定数组的范围内搜索指定对象。 在进行此调用之前，必须根据其元素的 Comparable 对范围进行升序排序（如通过 [sort(java.lang.Object],int,int) 方法）。 如果未排序，则结果未定义。 （如果范围包含不可相互比较的元素（例如，字符串和整数），则无法根据其元素的自然顺序对其进行排序，因此结果未定义。）如果范围包含多个等于指定对象的元素 , 不能保证会找到哪一个。

参数：

返回:

搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

binarySearch

public static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)

使用二分搜索算法在指定数组中搜索指定对象。 在进行此调用之前，必须根据指定的比较器（如通过 [sort(T], Comparator) 方法）对数组进行升序排序。 如果未排序，则结果未定义。 如果数组包含多个等于指定对象的元素，则无法保证会找到哪一个。

类型参数：

参数:

返回:

搜索键的索引，如果它包含在数组中； 否则，（-（插入点）- 1）。 插入点定义为将键插入数组的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定的键，则为 a.length。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

binarySearch

public static <T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)

使用二分搜索算法在指定数组的范围内搜索指定对象。 在进行此调用之前，必须根据指定的比较器（如通过 [sort(T], int, int, Comparator) 方法）对范围进行升序排序。 如果未排序，则结果未定义。 如果范围包含多个等于指定对象的元素，则无法保证会找到哪一个。

类型参数：

参数:

返回:

搜索键的索引，如果它包含在指定范围内的数组中； 否则，（-（插入点）- 1）。 插入点定义为键将插入数组的点：范围中大于键的第一个元素的索引，如果范围内的所有元素都小于指定的键，则为 toIndex。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

equals

public static boolean equals(long[] a, long[] a2)

如果两个指定的 long 数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。

参数：

返回:

如果两个数组相等则为true

equals

public static boolean equals(int[] a, int[] a2)

如果两个指定的 int 数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。

参数：

返回:

如果两个数组相等则为true

equals

public static boolean equals(short[] a, short[] a2)

如果两个指定的 short 数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。

参数：

返回:

如果两个数组相等则为true

equals

public static boolean equals(char[] a, char[] a2)

如果两个指定的字符数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。

参数：

返回:

如果两个数组相等则为true

equals

public static boolean equals(byte[] a, byte[] a2)

如果两个指定的字节数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。

参数：

返回:

如果两个数组相等则为true

equals

public static boolean equals(boolean[] a, boolean[] a2)

如果两个指定的布尔值数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为两个数组相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。

参数：

返回:

如果两个数组相等则为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。）

参数：

返回:

如果两个数组相等则为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。）

参数：

返回:

如果两个数组相等则为true

equals

public static boolean equals(Object[] a, Object[] a2)

如果两个指定的 Objects 数组彼此相等，则返回 true。 如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为这两个数组相等。 如果 (e1==null ? e2==null : e1.equals(e2))，则认为两个对象 e1 和 e2 相等。 换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组引用都为空，则认为两个数组引用相等。

参数：

返回:

如果两个数组相等则为true

fill

public static void fill(long[] a, long val)

将指定的 long 值分配给指定的 long 数组的每个元素。

参数：

fill

public static void fill(long[] a, int fromIndex, int toIndex, long val)

将指定的 long 值分配给指定 long 数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）

参数：

Throws:

fill

public static void fill(int[] a, int val)

将指定的 int 值分配给指定的 int 数组的每个元素。

参数：

fill

public static void fill(int[] a, int fromIndex, int toIndex, int val)

将指定的 int 值分配给指定 int 数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）

参数：

Throws:

fill

public static void fill(short[] a, short val)

将指定的 short 值分配给指定的 short 数组的每个元素。

参数：

fill

public static void fill(short[] a, int fromIndex, int toIndex, short val)

将指定的 short 值分配给指定的 short 数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）

参数：

Throws:

fill

public static void fill(char[] a, char val)

将指定的 char 值分配给指定的 char 数组的每个元素。

参数：

fill

public static void fill(char[] a, int fromIndex, int toIndex, char val)

将指定的 char 值分配给指定字符数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）

参数：

Throws:

fill

public static void fill(byte[] a, byte val)

将指定的字节值分配给指定字节数组的每个元素。

参数：

fill

public static void fill(byte[] a, int fromIndex, int toIndex, byte val)

将指定的字节值分配给指定字节数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）

参数：

Throws:

fill

public static void fill(boolean[] a, boolean val)

将指定的布尔值分配给指定的布尔数组的每个元素。

参数：

fill

public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)

将指定的布尔值分配给指定布尔数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）

参数：

Throws:

fill

public static void fill(double[] a, double val)

将指定的 double 值分配给指定的 double 数组的每个元素。

参数：

fill

public static void fill(double[] a, int fromIndex, int toIndex, double val)

将指定的 double 值分配给指定的 double 数组的指定范围内的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）

参数：

Throws:

fill

public static void fill(float[] a, float val)

将指定的浮点值分配给指定浮点数组的每个元素。

参数：

fill

public static void fill(float[] a, int fromIndex, int toIndex, float val)

将指定的浮点值分配给指定浮点数组的指定范围的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）

参数：

Throws:

fill

public static void fill(Object[] a, Object val)

将指定的 Object 引用分配给指定的 Objects 数组的每个元素。

参数：

Throws:

fill

public static void fill(Object[] a, int fromIndex, int toIndex, Object val)

将指定的 Object 引用分配给指定的 Objects 数组的指定范围内的每个元素。 要填充的范围从 index fromIndex（含）扩展到 index toIndex（不含）。 （如果fromIndex==toIndex，则要填充的范围为空。）

参数：

Throws:

copyOf

public static <T> T[] copyOf(T[] original, int newLength)

复制指定的数组，截断或填充空值（如有必要），使副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含 null。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。 结果数组与原始数组的类完全相同。

类型参数：

参数:

返回:

原始数组的副本，被截断或用空值填充以获得指定的长度

Throws:

copyOf

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)

复制指定的数组，截断或填充空值（如有必要），使副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含 null。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。 结果数组属于 newType 类。

类型参数：

参数:

返回:

原始数组的副本，被截断或用空值填充以获得指定的长度

Throws:

copyOf

public static byte[] copyOf(byte[] original, int newLength)

复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含 (byte)0。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。

参数：

返回:

原始数组的副本，被截断或用零填充以获得指定的长度

Throws:

copyOf

public static short[] copyOf(short[] original, int newLength)

复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含（短）0。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。

参数：

返回:

原始数组的副本，被截断或用零填充以获得指定的长度

Throws:

copyOf

public static int[] copyOf(int[] original, int newLength)

复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始数组中无效的任何索引，副本将包含 0。当且仅当指定长度大于原始数组的长度时，此类索引才会存在。

参数：

返回:

原始数组的副本，被截断或用零填充以获得指定的长度

Throws:

copyOf

public static long[] copyOf(long[] original, int newLength)

复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含 0L。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。

参数：

返回:

原始数组的副本，被截断或用零填充以获得指定的长度

Throws:

copyOf

public static char[] copyOf(char[] original, int newLength)

复制指定的数组，用空字符截断或填充（如有必要），使副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含“\u000”。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。

参数：

返回:

原始数组的副本，被截断或用空字符填充以获得指定的长度

Throws:

copyOf

public static float[] copyOf(float[] original, int newLength)

复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但不是原始索引的任何索引，副本将包含 0f。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。

参数：

返回:

原始数组的副本，被截断或用零填充以获得指定的长度

Throws:

copyOf

public static double[] copyOf(double[] original, int newLength)

复制指定的数组，用零截断或填充（如有必要），以便副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但不是原始索引的任何索引，副本将包含 0d。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。

参数：

返回:

原始数组的副本，被截断或用零填充以获得指定的长度

Throws:

copyOf

public static boolean[] copyOf(boolean[] original, int newLength)

复制指定的数组，用 false 截断或填充（如果需要），使副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但在原始副本中无效的任何索引，副本将包含 false。 当且仅当指定长度大于原始数组的长度时，此类索引才会存在。

参数：

返回:

原始数组的副本，被截断或填充假元素以获得指定的长度

Throws:

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。

结果数组与原始数组的类完全相同。

类型参数：

参数:

返回:

包含原始数组中指定范围的新数组，截断或填充空值以获得所需的长度

Throws:

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 类。

类型参数：

参数:

返回:

包含原始数组中指定范围的新数组，截断或填充空值以获得所需的长度

Throws:

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。

参数：

返回:

包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度

Throws:

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。

参数：

返回:

包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度

Throws:

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。

参数：

返回:

包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度

Throws:

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。

参数：

返回:

包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度

Throws:

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。

参数：

返回:

包含原始数组中指定范围的新数组，截断或填充空字符以获得所需的长度

Throws:

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。

参数：

返回:

包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度

Throws:

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。

参数：

返回:

包含原始数组中指定范围的新数组，截断或填充零以获得所需的长度

Throws:

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。

参数：

返回:

包含原始数组中指定范围的新数组，截断或填充错误元素以获得所需的长度

Throws:

asList

@SafeVarargs public static <T> List<T> asList(T… a)

返回由指定数组支持的固定大小的列表。 （将返回的列表“写入”到数组的更改。）此方法充当基于数组和基于集合的 API 之间的桥梁，与 Collection#toArray 结合使用。 返回的列表是可序列化的并实现了 RandomAccess。

此方法还提供了一种方便的方法来创建一个固定大小的列表，该列表已初始化为包含多个元素：

     List<String> stooges = Arrays.asList("Larry", "Moe", "Curly"); 

类型参数:

参数:

返回:

指定数组的列表视图

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。

参数：

返回:

一个基于内容的哈希码

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。

参数：

返回:

一个基于内容的哈希码

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。

参数：

返回:

一个基于内容的哈希码

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。

参数：

返回:

一个基于内容的哈希码

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。

参数：

返回:

一个基于内容的哈希码

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。

参数：

返回:

一个基于内容的哈希码

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。

参数：

返回:

一个基于内容的哈希码

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。

参数：

返回:

一个基于内容的哈希码

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。

参数：

返回:

一个基于内容的哈希码

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。

参数：

返回:

一个基于深度内容的哈希码

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。

请注意，此定义允许任何深度的空元素。

如果任一指定的数组直接或通过一个或多个数组级别间接将自身包含为元素，则此方法的行为是未定义的。

参数：

返回:

如果两个数组相等则为true

toString

public static String toString(long[] a)

返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 (“[]”) 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(long) 将元素转换为字符串。 如果 a 为空，则返回“空”。

参数：

返回:

a 的字符串表示

toString

public static String toString(int[] a)

返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 (“[]”) 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(int) 将元素转换为字符串。 如果 a 为空，则返回“空”。

参数：

返回:

a 的字符串表示

toString

public static String toString(short[] a)

返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 (“[]”) 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(short) 将元素转换为字符串。 如果 a 为空，则返回“空”。

参数：

返回:

a 的字符串表示

toString

public static String toString(char[] a)

返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 (“[]”) 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(char) 将元素转换为字符串。 如果 a 为空，则返回“空”。

参数：

返回:

a 的字符串表示

toString

public static String toString(byte[] a)

返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 (“[]”) 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(byte) 将元素转换为字符串。 如果 a 为空，则返回“空”。

参数：

返回:

a 的字符串表示

toString

public static String toString(boolean[] a)

返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 (“[]”) 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(boolean) 将元素转换为字符串。 如果 a 为空，则返回“空”。

参数：

返回:

a 的字符串表示

toString

public static String toString(float[] a)

返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 (“[]”) 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(float) 将元素转换为字符串。 如果 a 为空，则返回“空”。

参数：

返回:

a 的字符串表示

toString

public static String toString(double[] a)

返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号 (“[]”) 中。 相邻元素由字符“,”（逗号后跟一个空格）分隔。 通过 String.valueOf(double) 将元素转换为字符串。 如果 a 为空，则返回“空”。

参数：

返回:

a 的字符串表示

toString

public static String toString(Object[] a)

返回指定数组内容的字符串表示形式。 如果数组包含其他数组作为元素，它们会通过继承自 Object 的 Object#toString 方法转换为字符串，该方法描述的是它们的标识而不是它们的内容。

此方法返回的值等于 Arrays.asList(a).toString() 将返回的值，除非 a 为 null，在这种情况下返回“null”。

参数：

返回:

a 的字符串表示

deepToString

public static String deepToString(Object[] a)

返回指定数组的“深层内容”的字符串表示形式。如果数组包含其他数组作为元素，则字符串表示包含它们的内容等等。此方法设计用于将多维数组转换为字符串。

字符串表示由数组元素的列表组成，括在方括号 (“[]”) 中。相邻元素由字符“,”（逗号后跟一个空格）分隔。元素通过 String.valueOf(Object) 转换为字符串，除非它们本身是数组。

如果元素 e 是原始类型的数组，则通过调用 Arrays.toString(e) 的适当重载将其转换为字符串。如果元素 e 是引用类型的数组，则通过递归调用此方法将其转换为字符串。

为避免无限递归，如果指定数组包含自身作为元素，或者包含通过一层或多层数组间接引用自身，则将自引用转换为字符串“[…]”。例如，仅包含对其自身的引用的数组将呈现为“[[…]]”。

如果指定的数组为 null，则此方法返回“null”。

参数：

返回:

a 的字符串表示

setAll

public static <T> void setAll(T[] array, IntFunction<? extends T> generator)

设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，则将其转发给调用者，并且数组处于不确定状态。

类型参数：

参数:

Throws:

parallelSetAll

public static <T> void parallelSetAll(T[] array, IntFunction<? extends T> generator)

使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。

如果生成器函数抛出异常，则从 parallelSetAll 中抛出未经检查的异常，并且数组处于不确定状态。

类型参数：

参数:

Throws:

setAll

public static void setAll(int[] array, IntUnaryOperator generator)

设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，则将其转发给调用者，并且数组处于不确定状态。

参数：

Throws:

parallelSetAll

public static void parallelSetAll(int[] array, IntUnaryOperator generator)

使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。

如果生成器函数抛出异常，则从 parallelSetAll 中抛出未经检查的异常，并且数组处于不确定状态。

参数：

Throws:

setAll

public static void setAll(long[] array, IntToLongFunction generator)

设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，则将其转发给调用者，并且数组处于不确定状态。

参数：

Throws:

parallelSetAll

public static void parallelSetAll(long[] array, IntToLongFunction generator)

使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。

如果生成器函数抛出异常，则从 parallelSetAll 中抛出未经检查的异常，并且数组处于不确定状态。

参数：

Throws:

setAll

public static void setAll(double[] array, IntToDoubleFunction generator)

设置指定数组的所有元素，使用提供的生成器函数计算每个元素。

如果生成器函数抛出异常，则将其转发给调用者，并且数组处于不确定状态。

参数：

Throws:

parallelSetAll

public static void parallelSetAll(double[] array, IntToDoubleFunction generator)

使用提供的生成器函数并行设置指定数组的所有元素来计算每个元素。

如果生成器函数抛出异常，则从 parallelSetAll 中抛出未经检查的异常，并且数组处于不确定状态。

参数：

Throws:

spliterator

public static <T> Spliterator<T> spliterator(T[] array)

返回一个涵盖所有指定数组的 Spliterator。

spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。

类型参数：

参数:

返回:

数组元素的拆分器

spliterator

public static <T> Spliterator<T> spliterator(T[] array, int startInclusive, int endExclusive)

返回一个Spliterator，覆盖指定数组的指定范围。

spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。

类型参数：

参数:

返回:

数组元素的拆分器

Throws:

spliterator

public static Spliterator.OfInt spliterator(int[] array)

返回一个 Spliterator.OfInt 覆盖所有指定的数组。

spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。

参数：

返回:

数组元素的拆分器

spliterator

public static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive)

返回一个 Spliterator.OfInt 覆盖指定数组的指定范围。

spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。

参数：

返回:

数组元素的拆分器

Throws:

spliterator

public static Spliterator.OfLong spliterator(long[] array)

返回一个 Spliterator.OfLong 覆盖所有指定的数组。

spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。

参数：

返回:

数组元素的拆分器

spliterator

public static Spliterator.OfLong spliterator(long[] array, int startInclusive, int endExclusive)

返回一个 Spliterator.OfLong 覆盖指定数组的指定范围。

spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。

参数：

返回:

数组元素的拆分器

Throws:

spliterator

public static Spliterator.OfDouble spliterator(double[] array)

返回一个 Spliterator.OfDouble 覆盖所有指定的数组。

spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。

参数：

返回:

数组元素的拆分器

spliterator

public static Spliterator.OfDouble spliterator(double[] array, int startInclusive, int endExclusive)

返回一个 Spliterator.OfDouble，覆盖指定数组的指定范围。

spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED、Spliterator#ORDERED 和 Spliterator#IMMUTABLE。

参数：

返回:

数组元素的拆分器

Throws:

stream

public static <T> Stream<T> stream(T[] array)

返回以指定数组为源的顺序流。

类型参数：

参数:

返回:

数组的 Stream

stream

public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive)

返回以指定数组的指定范围作为源的顺序流。

类型参数：

参数:

返回:

数组范围的流

Throws:

stream

public static IntStream stream(int[] array)

返回以指定数组作为源的顺序 IntStream。

参数：

返回:

数组的 IntStream

stream

public static IntStream stream(int[] array, int startInclusive, int endExclusive)

返回以指定数组的指定范围作为源的顺序 IntStream。

参数：

返回:

数组范围的 IntStream

Throws:

stream

public static LongStream stream(long[] array)

返回以指定数组为源的顺序 LongStream。

参数：

返回:

数组的 LongStream

stream

public static LongStream stream(long[] array, int startInclusive, int endExclusive)

返回以指定数组的指定范围作为源的顺序 LongStream。

参数：

返回:

数组范围的 LongStream

Throws:

stream

public static DoubleStream stream(double[] array)

返回以指定数组为源的顺序 DoubleStream。

参数：

返回:

数组的 DoubleStream

stream

public static DoubleStream stream(double[] array, int startInclusive, int endExclusive)

返回以指定数组的指定范围作为源的顺序 DoubleStream。

参数：

返回:

数组范围的 DoubleStream

Throws: