创新互联鸿蒙OS教程：鸿蒙OSArrays

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 > void parallelSort(T[] a)

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

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

类型参数：

参数:

Throws:

parallelSort

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

根据其元素的 Comparable 对指定对象数组的指定范围进行升序排序。 要排序的范围从 index fromIndex（包括）扩展到 index toIndex（不包括）。 （如果fromIndex==toIndex，则要排序的范围为空。）该范围内的所有元素都必须实现Comparable接口。 此外，此范围内的所有元素必须相互可比较（即，e1.compareTo(e2) 不得为数组中的任何元素 e1 和 e2 抛出 ClassCastException）。

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

类型参数：

参数:

Throws: