Arrays (Java Platform SE 8 )

java.lang.Object
- java.util.Arrays

```
public class Arrays
extends Object
```
这个类包含用于操作数组（如排序和搜索）的各种方法。此类还包含一个允许数组被视为列表的静态工厂。
这个类中的方法把一NullPointerException，如果指定的数组引用是无效的，除非另有说明。

该方法中包含的文档这一类包括的实现简要描述。这样的描述应该是实现注意事项，而不是部分的规范。实施者应随时替代其他算法，只要规范本身就是坚持。（例如，用sort(Object[])算法不需要归并排序，但它必须稳定的。）

这个班的一员 Java Collections Framework。

从以下版本开始：

一点二

方法摘要

所有方法静态方法具体的方法
Modifier and Type	Method and Description
`static <T> List<T>`	`asList(T... a)` 返回由指定数组支持的一个固定大小的列表。
`static int`	`binarySearch(byte[] a, byte key)` 使用二进制搜索算法搜索指定的值的字节数组。
`static int`	`binarySearch(byte[] a, int fromIndex, int toIndex, byte key)` 使用二进制搜索算法搜索指定值指定的字节数组的范围。
`static int`	`binarySearch(char[] a, char key)` 搜索指定的字符数组的指定值使用二进制搜索算法。
`static int`	`binarySearch(char[] a, int fromIndex, int toIndex, char key)` 搜索范围的指定字符数组的指定值使用二进制搜索算法。
`static int`	`binarySearch(double[] a, double key)` 使用二进制搜索算法搜索指定值的指定数组。
`static int`	`binarySearch(double[] a, int fromIndex, int toIndex, double key)` 使用二进制搜索算法搜索指定值的指定数组的范围。
`static int`	`binarySearch(float[] a, float key)` 使用二进制搜索算法在指定值中搜索指定的浮点数组。
`static int`	`binarySearch(float[] a, int fromIndex, int toIndex, float key)` 使用二进制搜索算法搜索指定值的指定数组的范围。
`static int`	`binarySearch(int[] a, int key)` 搜索指定的数组中的值指定的值使用二进制搜索算法。
`static int`	`binarySearch(int[] a, int fromIndex, int toIndex, int key)` 搜索范围指定的数组对象为指定的值使用二进制搜索算法。
`static int`	`binarySearch(long[] a, int fromIndex, int toIndex, long key)` 使用二进制搜索算法搜索指定的指定值的指定数组的范围。
`static int`	`binarySearch(long[] a, long key)` 使用二进制搜索算法搜索指定的指定值的数组。
`static int`	`binarySearch(Object[] a, int fromIndex, int toIndex, Object key)` 使用二进制搜索算法搜索指定对象的指定数组的范围。
`static int`	`binarySearch(Object[] a, Object key)` 使用二进制搜索算法在指定的对象中搜索指定的数组。
`static int`	`binarySearch(short[] a, int fromIndex, int toIndex, short key)` 使用二进制搜索算法搜索指定值的指定数组的范围。
`static int`	`binarySearch(short[] a, short key)` 使用二进制搜索算法搜索指定值的指定数组的短裤。
`static <T> int`	`binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)` 使用二进制搜索算法搜索指定对象的指定数组的范围。
`static <T> int`	`binarySearch(T[] a, T key, Comparator<? super T> c)` 使用二进制搜索算法在指定的对象中搜索指定的数组。
`static boolean[]`	`copyOf(boolean[] original, int newLength)` 复制指定的数组，截断或填充 `false`（如果必要）所以副本具有指定的长度。
`static byte[]`	`copyOf(byte[] original, int newLength)` 复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。
`static char[]`	`copyOf(char[] original, int newLength)` 复制指定的数组，截断或空字符填充（如果必要）所以副本具有指定的长度。
`static double[]`	`copyOf(double[] original, int newLength)` 复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。
`static float[]`	`copyOf(float[] original, int newLength)` 复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。
`static int[]`	`copyOf(int[] original, int newLength)` 复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。
`static long[]`	`copyOf(long[] original, int newLength)` 复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。
`static short[]`	`copyOf(short[] original, int newLength)` 复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。
`static <T> T[]`	`copyOf(T[] original, int newLength)` 复制指定的数组，截断或填充空值（如果需要）所以副本具有指定的长度。
`static <T,U> T[]`	`copyOf(U[] original, int newLength, 类<? extends T[]> newType)` 复制指定的数组，截断或填充空值（如果需要）所以副本具有指定的长度。
`static boolean[]`	`copyOfRange(boolean[] original, int from, int to)` 将指定的数组指定的范围复制到一个新的数组中。
`static byte[]`	`copyOfRange(byte[] original, int from, int to)` 将指定的数组指定的范围复制到一个新的数组中。
`static char[]`	`copyOfRange(char[] original, int from, int to)` 将指定的数组指定的范围复制到一个新的数组中。
`static double[]`	`copyOfRange(double[] original, int from, int to)` 将指定的数组指定的范围复制到一个新的数组中。
`static float[]`	`copyOfRange(float[] original, int from, int to)` 将指定的数组指定的范围复制到一个新的数组中。
`static int[]`	`copyOfRange(int[] original, int from, int to)` 将指定的数组指定的范围复制到一个新的数组中。
`static long[]`	`copyOfRange(long[] original, int from, int to)` 将指定的数组指定的范围复制到一个新的数组中。
`static short[]`	`copyOfRange(short[] original, int from, int to)` 将指定的数组指定的范围复制到一个新的数组中。
`static <T> T[]`	`copyOfRange(T[] original, int from, int to)` 将指定的数组指定的范围复制到一个新的数组中。
`static <T,U> T[]`	`copyOfRange(U[] original, int from, int to, 类<? extends T[]> newType)` 将指定的数组指定的范围复制到一个新的数组中。
`static boolean`	`deepEquals(Object[] a1, Object[] a2)` 返回指定数组 `true`如果两深深的平等彼此。
`static int`	`deepHashCode(Object[] a)` 返回基于指定数组的“深度内容”的哈希代码。
`static String`	`deepToString(Object[] a)` 返回指定数组的“深度内容”的字符串表示形式。
`static boolean`	`equals(boolean[] a, boolean[] a2)` 返回 `true`如果两个指定阵列的布尔值平等的彼此。
`static boolean`	`equals(byte[] a, byte[] a2)` 返回 `true`如果两个指定的字节数组是一平等的。
`static boolean`	`equals(char[] a, char[] a2)` 返回 `true`如果两个指定字符数组平等的彼此。
`static boolean`	`equals(double[] a, double[] a2)` 返回指定数组 `true`如果两双打都平等的彼此。
`static boolean`	`equals(float[] a, float[] a2)` 返回 `true`如果两个指定阵列的浮动平等的彼此。
`static boolean`	`equals(int[] a, int[] a2)` 返回 `true`如果两个指定的int数组是一平等的。
`static boolean`	`equals(long[] a, long[] a2)` 返回 `true`如果两个指定阵列的渴望是平等的彼此。
`static boolean`	`equals(Object[] a, Object[] a2)` 返回 `true`如果两个指定对象数组是平等的彼此。
`static boolean`	`equals(short[] a, short[] a2)` 返回 `true`如果两个指定阵列的短裤是平等的彼此。
`static void`	`fill(boolean[] a, boolean val)` 将指定的布尔值来指定数组的每个元素的布尔值。
`static void`	`fill(boolean[] a, int fromIndex, int toIndex, boolean val)` 将指定的布尔值来指定数组的每个元素的布尔值指定的范围。
`static void`	`fill(byte[] a, byte val)` 将指定的字节值分配给指定的字节数组的每个元素。
`static void`	`fill(byte[] a, int fromIndex, int toIndex, byte val)` 将指定的字节值分配给指定的字节数组的指定范围的每个元素。
`static void`	`fill(char[] a, char val)` 将指定的字符值为指定的字符数组的每个元素。
`static void`	`fill(char[] a, int fromIndex, int toIndex, char val)` 将指定的字符值为指定的字符数组的指定范围内的每个元素。
`static void`	`fill(double[] a, double val)` 将指定的双值分配给指定数组的每个元素的两个元素。
`static void`	`fill(double[] a, int fromIndex, int toIndex, double val)` 将指定的双值分配给指定数组的指定数组的每个元素的指定范围内的每个元素。
`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值来指定数组的每个元素的值。
`static void`	`fill(int[] a, int fromIndex, int toIndex, int val)` 将指定的int值为指定数组的每个元素对象的指定范围。
`static void`	`fill(long[] a, int fromIndex, int toIndex, long val)` 将指定的长值分配给指定数组的指定数组的每个元素的值。
`static void`	`fill(long[] a, long val)` 将指定的长值分配给指定数组的每个元素的值。
`static void`	`fill(Object[] a, int fromIndex, int toIndex, Object val)` 将指定的对象引用分配给指定的对象数组的指定范围的每个元素。
`static void`	`fill(Object[] a, Object val)` 将指定的对象引用分配给指定的对象数组的每个元素。
`static void`	`fill(short[] a, int fromIndex, int toIndex, short val)` 将指定的短值分配给指定数组的指定数组的每个元素的值。
`static void`	`fill(short[] a, short val)` 将指定的短值分配给指定数组的每个元素的。
`static int`	`hashCode(boolean[] a)` 返回基于指定数组的内容的哈希代码。
`static int`	`hashCode(byte[] a)` 返回基于指定数组的内容的哈希代码。
`static int`	`hashCode(char[] a)` 返回基于指定数组的内容的哈希代码。
`static int`	`hashCode(double[] a)` 返回基于指定数组的内容的哈希代码。
`static int`	`hashCode(float[] a)` 返回基于指定数组的内容的哈希代码。
`static int`	`hashCode(int[] a)` 返回基于指定数组的内容的哈希代码。
`static int`	`hashCode(long[] a)` 返回基于指定数组的内容的哈希代码。
`static int`	`hashCode(Object[] a)` 返回基于指定数组的内容的哈希代码。
`static int`	`hashCode(short[] a)` 返回基于指定数组的内容的哈希代码。
`static void`	`parallelPrefix(double[] array, DoubleBinaryOperator op)` 堆，并联，每个元素的数组的地方，使用提供的功能。
`static void`	`parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)` 对给定的数组的子 `parallelPrefix(double[], DoubleBinaryOperator)`。
`static void`	`parallelPrefix(int[] array, IntBinaryOperator op)` 堆，并联，每个元素的数组的地方，使用提供的功能。
`static void`	`parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)` 对给定的数组的子 `parallelPrefix(int[], IntBinaryOperator)`。
`static void`	`parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)` 对给定的数组的子 `parallelPrefix(long[], LongBinaryOperator)`。
`static void`	`parallelPrefix(long[] array, LongBinaryOperator op)` 堆，并联，每个元素的数组的地方，使用提供的功能。
`static <T> void`	`parallelPrefix(T[] array, BinaryOperator<T> op)` 堆，并联，每个元素的数组的地方，使用提供的功能。
`static <T> void`	`parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)` 对给定的数组的子 `parallelPrefix(Object[], BinaryOperator)`。
`static void`	`parallelSetAll(double[] array, IntToDoubleFunction generator)` 将指定的数组的所有元素，在并行中，使用提供的生成器函数来计算每个元素。
`static void`	`parallelSetAll(int[] array, IntUnaryOperator generator)` 将指定的数组的所有元素，在并行中，使用提供的生成器函数来计算每个元素。
`static void`	`parallelSetAll(long[] array, IntToLongFunction generator)` 将指定的数组的所有元素，在并行中，使用提供的生成器函数来计算每个元素。
`static <T> void`	`parallelSetAll(T[] array, IntFunction<? extends T> generator)` 将指定的数组的所有元素，在并行中，使用提供的生成器函数来计算每个元素。
`static void`	`parallelSort(byte[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`parallelSort(byte[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的数值顺序。
`static void`	`parallelSort(char[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`parallelSort(char[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的数值顺序。
`static void`	`parallelSort(double[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`parallelSort(double[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的数值顺序。
`static void`	`parallelSort(float[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`parallelSort(float[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的数值顺序。
`static void`	`parallelSort(int[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`parallelSort(int[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的数值顺序。
`static void`	`parallelSort(long[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`parallelSort(long[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的数值顺序。
`static void`	`parallelSort(short[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`parallelSort(short[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的数值顺序。
`static <T extends Comparable<? super T>> void`	`parallelSort(T[] a)` 指定的对象数组排序为升序，根据其元素的 natural ordering。
`static <T> void`	`parallelSort(T[] a, Comparator<? super T> cmp)` 根据指定的比较器所指定的顺序对指定的对象数组进行排序。
`static <T extends Comparable<? super T>> void`	`parallelSort(T[] a, int fromIndex, int toIndex)` 各种各样的指定对象数组的指定范围为升序，根据其元素的 natural ordering。
`static <T> void`	`parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)` 根据指定的比较器指定的顺序，对指定的对象数组的指定范围进行排序。
`static void`	`setAll(double[] array, IntToDoubleFunction generator)` 设置指定数组的所有元素，使用提供的生成器函数来计算每个元素。
`static void`	`setAll(int[] array, IntUnaryOperator generator)` 设置指定数组的所有元素，使用提供的生成器函数来计算每个元素。
`static void`	`setAll(long[] array, IntToLongFunction generator)` 设置指定数组的所有元素，使用提供的生成器函数来计算每个元素。
`static <T> void`	`setAll(T[] array, IntFunction<? extends T> generator)` 设置指定数组的所有元素，使用提供的生成器函数来计算每个元素。
`static void`	`sort(byte[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`sort(byte[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的顺序。
`static void`	`sort(char[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`sort(char[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的顺序。
`static void`	`sort(double[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`sort(double[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的顺序。
`static void`	`sort(float[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`sort(float[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的顺序。
`static void`	`sort(int[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`sort(int[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的顺序。
`static void`	`sort(long[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`sort(long[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的顺序。
`static void`	`sort(Object[] a)` 指定的对象数组排序为升序，根据其元素的 natural ordering。
`static void`	`sort(Object[] a, int fromIndex, int toIndex)` 各种各样的指定对象数组的指定范围为升序，根据其元素的 natural ordering。
`static void`	`sort(short[] a)` 将指定的数组排序为上升的数值顺序。
`static void`	`sort(short[] a, int fromIndex, int toIndex)` 将数组的指定范围排序为上升的顺序。
`static <T> void`	`sort(T[] a, Comparator<? super T> c)` 根据指定的比较器所指定的顺序对指定的对象数组进行排序。
`static <T> void`	`sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)` 根据指定的比较器指定的顺序，对指定的对象数组的指定范围进行排序。
`static Spliterator.OfDouble`	`spliterator(double[] array)` 返回一个 `Spliterator.OfDouble`覆盖所有指定的数组。
`static Spliterator.OfDouble`	`spliterator(double[] array, int startInclusive, int endExclusive)` 返回一个 `Spliterator.OfDouble`覆盖指定数组的指定范围。
`static Spliterator.OfInt`	`spliterator(int[] array)` 返回一个 `Spliterator.OfInt`覆盖所有指定的数组。
`static Spliterator.OfInt`	`spliterator(int[] array, int startInclusive, int endExclusive)` 返回一个 `Spliterator.OfInt`覆盖指定数组的指定范围。
`static Spliterator.OfLong`	`spliterator(long[] array)` 返回一个 `Spliterator.OfLong`覆盖所有指定的数组。
`static Spliterator.OfLong`	`spliterator(long[] array, int startInclusive, int endExclusive)` 返回一个 `Spliterator.OfLong`覆盖指定数组的指定范围。
`static <T> Spliterator<T>`	`spliterator(T[] array)` 返回一个 `Spliterator`覆盖所有指定的数组。
`static <T> Spliterator<T>`	`spliterator(T[] array, int startInclusive, int endExclusive)` 返回一个 `Spliterator`覆盖指定数组的指定范围。
`static DoubleStream`	`stream(double[] array)` 返回与指定的数组作为其源序列 `DoubleStream`。
`static DoubleStream`	`stream(double[] array, int startInclusive, int endExclusive)` 返回与指定的数组作为其源指定范围内连续 `DoubleStream`。
`static IntStream`	`stream(int[] array)` 返回与指定的数组作为其源序列 `IntStream`。
`static IntStream`	`stream(int[] array, int startInclusive, int endExclusive)` 返回与指定的数组作为其源指定范围内连续 `IntStream`。
`static LongStream`	`stream(long[] array)` 返回与指定的数组作为其源序列 `LongStream`。
`static LongStream`	`stream(long[] array, int startInclusive, int endExclusive)` 返回与指定的数组作为其源指定范围内连续 `LongStream`。
`static <T> Stream<T>`	`stream(T[] array)` 返回与指定的数组作为其源序列 `Stream`。
`static <T> Stream<T>`	`stream(T[] array, int startInclusive, int endExclusive)` 返回与指定的数组作为其源指定范围内连续 `Stream`。
`static String`	`toString(boolean[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(byte[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(char[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(double[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(float[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(int[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(long[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(Object[] a)` 返回指定数组的内容的字符串表示形式。
`static String`	`toString(short[] a)` 返回指定数组的内容的字符串表示形式。

Methods inherited from class 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。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
  - sort
```
public static void sort(int[] a,
                        int fromIndex,
                        int toIndex)
```
    将数组的指定范围排序为上升的顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(long[] a)
```
    将指定的数组排序为上升的数值顺序。
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
  - sort
```
public static void sort(long[] a,
                        int fromIndex,
                        int toIndex)
```
    将数组的指定范围排序为上升的顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(short[] a)
```
    将指定的数组排序为上升的数值顺序。
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
  - sort
```
public static void sort(short[] a,
                        int fromIndex,
                        int toIndex)
```
    将数组的指定范围排序为上升的顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(char[] a)
```
    将指定的数组排序为上升的数值顺序。
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
  - sort
```
public static void sort(char[] a,
                        int fromIndex,
                        int toIndex)
```
    将数组的指定范围排序为上升的顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(byte[] a)
```
    将指定的数组排序为上升的数值顺序。
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
  - sort
```
public static void sort(byte[] a,
                        int fromIndex,
                        int toIndex)
```
    将数组的指定范围排序为上升的顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(float[] a)
```
    将指定的数组排序为上升的数值顺序。
    的<关系不提供所有浮点值总为：-0.0f == 0.0f是true和Float.NaN值比不小于，大于或等于任何价值，甚至本身。该方法采用的方法Float.compareTo(java.lang.Float)施加的总订单：-0.0f看作是低于价值0.0f和Float.NaN是大于任何其他值都Float.NaN值都是相同的。
    
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
  - sort
```
public static void sort(float[] a,
                        int fromIndex,
                        int toIndex)
```
    将数组的指定范围排序为上升的顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    的<关系不提供所有浮点值总为：-0.0f == 0.0f是true和Float.NaN值比不小于，大于或等于任何价值，甚至本身。该方法采用的方法Float.compareTo(java.lang.Float)施加的总订单：-0.0f看作是低于价值0.0f和Float.NaN是大于任何其他值都Float.NaN值都是相同的。
    
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - sort
```
public static void sort(double[] a)
```
    将指定的数组排序为上升的数值顺序。
    的<关系并不提供所有双值总为：-0.0d == 0.0d是true和Double.NaN值比不小于，大于或等于任何价值，甚至本身。该方法采用的方法Double.compareTo(java.lang.Double)施加的总订单：-0.0d看作是低于价值0.0d和Double.NaN是大于任何其他值都Double.NaN值都是相同的。
    
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
  - sort
```
public static void sort(double[] a,
                        int fromIndex,
                        int toIndex)
```
    将数组的指定范围排序为上升的顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    的<关系并不提供所有双值总为：-0.0d == 0.0d是true和Double.NaN值比不小于，大于或等于任何价值，甚至本身。该方法采用的方法Double.compareTo(java.lang.Double)施加的总订单：-0.0d看作是低于价值0.0d和Double.NaN是大于任何其他值都Double.NaN值都是相同的。
    
    实施注：排序算法是由Vladimir Yaroslavskiy、Jon Bentley双支点快速排序，和Joshua Bloch。该算法为O（n log（n））在多个数据集，导致其他quicksorts降解二次性能，通常比传统的（一个支点）快速排序的实现。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - parallelSort
```
public static void parallelSort(byte[] a)
```
    将指定的数组排序为上升的数值顺序。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(byte[] a,
                                int fromIndex,
                                int toIndex)
```
    将数组的指定范围排序为上升的数值顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的指定范围的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(char[] a)
```
    将指定的数组排序为上升的数值顺序。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(char[] a,
                                int fromIndex,
                                int toIndex)
```
    将数组的指定范围排序为上升的数值顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的指定范围的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(short[] a)
```
    将指定的数组排序为上升的数值顺序。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(short[] a,
                                int fromIndex,
                                int toIndex)
```
    将数组的指定范围排序为上升的数值顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的指定范围的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(int[] a)
```
    将指定的数组排序为上升的数值顺序。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(int[] a,
                                int fromIndex,
                                int toIndex)
```
    将数组的指定范围排序为上升的数值顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的指定范围的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(long[] a)
```
    将指定的数组排序为上升的数值顺序。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(long[] a,
                                int fromIndex,
                                int toIndex)
```
    将数组的指定范围排序为上升的数值顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的指定范围的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(float[] a)
```
    将指定的数组排序为上升的数值顺序。
    的<关系不提供所有浮点值总为：-0.0f == 0.0f是true和Float.NaN值比不小于，大于或等于任何价值，甚至本身。该方法采用的方法Float.compareTo(java.lang.Float)施加的总订单：-0.0f看作是低于价值0.0f和Float.NaN是大于任何其他值都Float.NaN值都是相同的。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(float[] a,
                                int fromIndex,
                                int toIndex)
```
    将数组的指定范围排序为上升的数值顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    的<关系不提供所有浮点值总为：-0.0f == 0.0f是true和Float.NaN值比不小于，大于或等于任何价值，甚至本身。该方法采用的方法Float.compareTo(java.lang.Float)施加的总订单：-0.0f看作是低于价值0.0f和Float.NaN是大于任何其他值都Float.NaN值都是相同的。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的指定范围的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(double[] a)
```
    将指定的数组排序为上升的数值顺序。
    的<关系并不提供所有双值总为：-0.0d == 0.0d是true和Double.NaN值比不小于，大于或等于任何价值，甚至本身。该方法采用的方法Double.compareTo(java.lang.Double)施加的总订单：-0.0d看作是低于价值0.0d和Double.NaN是大于任何其他值都Double.NaN值都是相同的。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static void parallelSort(double[] a,
                                int fromIndex,
                                int toIndex)
```
    将数组的指定范围排序为上升的数值顺序。范围要排序的索引 fromIndex，包容性的延伸，对指数 toIndex，独家。如果 fromIndex == toIndex、范围进行排序是空的。
    的<关系并不提供所有双值总为：-0.0d == 0.0d是true和Double.NaN值比不小于，大于或等于任何价值，甚至本身。该方法采用的方法Double.compareTo(java.lang.Double)施加的总订单：-0.0d看作是低于价值0.0d和Double.NaN是大于任何其他值都Double.NaN值都是相同的。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的指定范围的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数
    
    a -要排序的数组
    
    fromIndex -的第一要素，指标，进行排序
    
    toIndex -最后一个元素的索引，独家，进行排序
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static <T extends Comparable<? super T>> void parallelSort(T[] a)
```
    指定的对象数组排序为升序，根据其元素的 natural ordering。数组中的所有元素必须实现 Comparable接口。此外，数组中的所有元素必须相互比较（即 e1.compareTo(e2)不得把任何元素 e1和 e2数组中的 ClassCastException）。
    这种保证是稳定的：相等的元素不会被重新排序结果的排序。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数类型
    
    T的对象进行排序的类
    
    参数
    
    a -要排序的数组
    
    异常
    
    ClassCastException -如果数组包含不相互比较元素（例如，字符串和整数）
    
    IllegalArgumentException -（可选）如果数组的元素的自然顺序 Comparable发现违反合同
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static <T extends Comparable<? super T>> void parallelSort(T[] a,
                                                                  int fromIndex,
                                                                  int toIndex)
```
    各种各样的指定对象数组的指定范围为升序，根据其元素的 natural ordering。范围要排序的指标 fromIndex，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex、范围进行排序是空的。）在这个范围内的所有元素必须实现 Comparable接口。此外，在这个范围内的所有元素必须相互比较（即 e1.compareTo(e2)不得把任何元素 e1和 e2数组中的 ClassCastException）。
    这种保证是稳定的：相等的元素不会被重新排序结果的排序。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的指定范围的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数类型
    
    T的对象进行排序的类
    
    参数
    
    a -要排序的数组
    
    fromIndex -第一个元素的索引（含）进行排序
    
    toIndex -最后一个元素的索引（独家）进行排序
    
    异常
    
    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）。
    这种保证是稳定的：相等的元素不会被重新排序结果的排序。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数类型
    
    T的对象进行排序的类
    
    参数
    
    a -要排序的数组
    
    cmp -比较器确定数组的顺序。一个 null值表示元素的 natural ordering应使用。
    
    异常
    
    ClassCastException -如果数组包含不相互比较使用指定的比较器元件
    
    IllegalArgumentException -（可选）如果比较器被发现违反 Comparator合同
    
    从以下版本开始：
    
    一点八
  - parallelSort
```
public static <T> void parallelSort(T[] a,
                                    int fromIndex,
                                    int toIndex,
                                    Comparator<? super T> cmp)
```
    根据指定的比较器指定的顺序，对指定的对象数组的指定范围进行排序。范围要排序的指标 fromIndex，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex、范围进行排序是空的。）范围内的所有元素必须相互比较由指定的比较器（即 c.compare(e1, e2)不得把任何元素 e1和 e2范围在 ClassCastException）。
    这种保证是稳定的：相等的元素不会被重新排序结果的排序。
    
    Implementation Note:
    
    排序算法是一个平行的排序合并，打破了数组分为子数组，它们自己进行排序，然后合并。当亚阵列长度达到最小粒度的子数组排序方法使用适当的 Arrays.sort。如果指定数组的长度小于最小粒度，然后分类使用适当的 Arrays.sort方法。该算法需要一个工作空间不大于原来的数组的指定范围的大小。的 ForkJoin common pool用于执行并行任务。
    
    参数类型
    
    T的对象进行排序的类
    
    参数
    
    a -要排序的数组
    
    fromIndex -第一个元素的索引（含）进行排序
    
    toIndex -最后一个元素的索引（独家）进行排序
    
    cmp -比较器确定数组的顺序。一个 null值表示元素的 natural ordering应使用。
    
    异常
    
    IllegalArgumentException -如果 fromIndex > toIndex或（可选）如果数组的元素的自然顺序 Comparable发现违反合同
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
    
    ClassCastException -如果数组包含不相互比较元素（例如，字符串和整数）。
    
    从以下版本开始：
    
    一点八
  - sort
```
public static void sort(Object[] a)
```
    指定的对象数组排序为升序，根据其元素的 natural ordering。数组中的所有元素必须实现 Comparable接口。此外，数组中的所有元素必须相互比较（即 e1.compareTo(e2)不得把任何元素 e1和 e2数组中的 ClassCastException）。
    这种保证是稳定的：相等的元素不会被重新排序结果的排序。
    
    注：这是一个实现实现稳定、自适应迭代归并排序需要远少于n lg（n）比较，当输入阵列部分排序，同时提供传统的归并排序的性能时，输入数组的随机排列。如果输入数组几乎是排序的，实现需要约n个比较。临时存储的要求不同从一个小的常数为近排序的输入阵列到n / 2对象的参考随机排列的输入阵列。
    
    在相同的输入数组中，实现在其输入数组中具有相同的上升和下降的顺序，并且可以利用相同的输入数组的不同部分的上下顺序。它非常适合于合并两个或多个已排序数组：直接连接阵列和由此产生的数组排序。
    
    实施改编自Tim Peters的列表排序为Python（ TimSort）。它采用的技术，从Peter McIlroy的“乐观的排序和信息理论的复杂性”，在第四届研讨会上ANALCO ACM- SIAM离散算法，PP 467-474，一月1993。
    
    参数
    
    a -要排序的数组
    
    异常
    
    ClassCastException -如果数组包含不相互比较元素（例如，字符串和整数）
    
    IllegalArgumentException -（可选）如果数组的元素的自然顺序 Comparable发现违反合同
  - sort
```
public static void sort(Object[] a,
                        int fromIndex,
                        int toIndex)
```
    各种各样的指定对象数组的指定范围为升序，根据其元素的 natural ordering。范围要排序的指标 fromIndex，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex、范围进行排序是空的。）在这个范围内的所有元素必须实现 Comparable接口。此外，在这个范围内的所有元素必须相互比较（即 e1.compareTo(e2)不得把任何元素 e1和 e2数组中的 ClassCastException）。
    这种保证是稳定的：相等的元素不会被重新排序结果的排序。
    
    注：这是一个实现实现稳定、自适应迭代归并排序需要远少于n lg（n）比较，当输入阵列部分排序，同时提供传统的归并排序的性能时，输入数组的随机排列。如果输入数组几乎是排序的，实现需要约n个比较。临时存储的要求不同从一个小的常数为近排序的输入阵列到n / 2对象的参考随机排列的输入阵列。
    
    在相同的输入数组中，实现在其输入数组中具有相同的上升和下降的顺序，并且可以利用相同的输入数组的不同部分的上下顺序。它非常适合于合并两个或多个已排序数组：直接连接阵列和由此产生的数组排序。
    
    实施改编自Tim Peters的列表排序为Python（ TimSort）。它采用的技术，从Peter McIlroy的“乐观的排序和信息理论的复杂性”，在第四届研讨会上ANALCO ACM- SIAM离散算法，PP 467-474，一月1993。
    
    参数
    
    a -要排序的数组
    
    fromIndex -第一个元素的索引（含）进行排序
    
    toIndex -最后一个元素的索引（独家）进行排序
    
    异常
    
    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的“乐观的排序和信息理论的复杂性”，在第四届研讨会上ANALCO ACM- SIAM离散算法，PP 467-474，一月1993。
    
    参数类型
    
    T的对象进行排序的类
    
    参数
    
    a -要排序的数组
    
    c -比较器确定数组的顺序。一个 null值表示元素的 natural ordering应使用。
    
    异常
    
    ClassCastException -如果数组包含不相互比较使用指定的比较器元件
    
    IllegalArgumentException -（可选）如果比较器被发现违反 Comparator合同
  - sort
```
public static <T> void sort(T[] a,
                            int fromIndex,
                            int toIndex,
                            Comparator<? super T> c)
```
    根据指定的比较器指定的顺序，对指定的对象数组的指定范围进行排序。范围要排序的指标 fromIndex，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex、范围进行排序是空的。）范围内的所有元素必须相互比较由指定的比较器（即 c.compare(e1, e2)不得把任何元素 e1和 e2范围在 ClassCastException）。
    这种保证是稳定的：相等的元素不会被重新排序结果的排序。
    
    注：这是一个实现实现稳定、自适应迭代归并排序需要远少于n lg（n）比较，当输入阵列部分排序，同时提供传统的归并排序的性能时，输入数组的随机排列。如果输入数组几乎是排序的，实现需要约n个比较。临时存储的要求不同从一个小的常数为近排序的输入阵列到n / 2对象的参考随机排列的输入阵列。
    
    在相同的输入数组中，实现在其输入数组中具有相同的上升和下降的顺序，并且可以利用相同的输入数组的不同部分的上下顺序。它非常适合于合并两个或多个已排序数组：直接连接阵列和由此产生的数组排序。
    
    实施改编自Tim Peters的列表排序为Python（ TimSort）。它采用的技术，从Peter McIlroy的“乐观的排序和信息理论的复杂性”，在第四届研讨会上ANALCO ACM- SIAM离散算法，PP 467-474，一月1993。
    
    参数类型
    
    T的对象进行排序的类
    
    参数
    
    a -要排序的数组
    
    fromIndex -第一个元素的索引（含）进行排序
    
    toIndex -最后一个元素的索引（独家）进行排序
    
    c -比较器确定数组的顺序。一个 null值表示元素的 natural ordering应使用。
    
    异常
    
    ClassCastException -如果数组包含不相互比较使用指定的比较器元件。
    
    IllegalArgumentException -如果 fromIndex > toIndex或（可选）如果比较器被发现违反 Comparator合同
    
    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 -无副作用的，联想功能进行累积
    
    异常
    
    NullPointerException -如果指定数组或函数是空的
    
    从以下版本开始：
    
    一点八
  - parallelPrefix
```
public static <T> void parallelPrefix(T[] array,
                                      int fromIndex,
                                      int toIndex,
                                      BinaryOperator<T> op)
```
    对给定的数组的子 parallelPrefix(Object[], BinaryOperator)。
    
    参数类型
    
    T -数组中对象的类
    
    参数
    
    array -阵列
    
    fromIndex -第一个元素的索引，包括
    
    toIndex -最后一个元素的索引，独家
    
    op -无副作用的，联想功能进行累积
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    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 -无副作用的，联想功能进行累积
    
    异常
    
    NullPointerException -如果指定数组或函数是空的
    
    从以下版本开始：
    
    一点八
  - parallelPrefix
```
public static void parallelPrefix(long[] array,
                                  int fromIndex,
                                  int toIndex,
                                  LongBinaryOperator op)
```
    对给定的数组的子 parallelPrefix(long[], LongBinaryOperator)。
    
    参数
    
    array -阵列
    
    fromIndex -第一个元素的索引，包括
    
    toIndex -最后一个元素的索引，独家
    
    op -无副作用的，联想功能进行累积
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    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功能无副作用进行累积
    
    异常
    
    NullPointerException -如果指定数组或函数是空的
    
    从以下版本开始：
    
    一点八
  - parallelPrefix
```
public static void parallelPrefix(double[] array,
                                  int fromIndex,
                                  int toIndex,
                                  DoubleBinaryOperator op)
```
    对给定的数组的子 parallelPrefix(double[], DoubleBinaryOperator)。
    
    参数
    
    array -阵列
    
    fromIndex -第一个元素的索引，包括
    
    toIndex -最后一个元素的索引，独家
    
    op -无副作用的，联想功能进行累积
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    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 -无副作用的，联想功能进行累积
    
    异常
    
    NullPointerException -如果指定数组或函数是空的
    
    从以下版本开始：
    
    一点八
  - parallelPrefix
```
public static void parallelPrefix(int[] array,
                                  int fromIndex,
                                  int toIndex,
                                  IntBinaryOperator op)
```
    对给定的数组的子 parallelPrefix(int[], IntBinaryOperator)。
    
    参数
    
    array -阵列
    
    fromIndex -第一个元素的索引，包括
    
    toIndex -最后一个元素的索引，独家
    
    op -无副作用的，联想功能进行累积
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > array.length
    
    NullPointerException -如果指定数组或函数是空的
    
    从以下版本开始：
    
    一点八
  - binarySearch
```
public static int binarySearch(long[] a,
                               long key)
```
    使用二进制搜索算法搜索指定的指定值的数组。数组必须排序（由 sort(long[])法）进行调用之前。如果它没有排序，结果是不确定的。如果数组包含具有指定值的多个元素，则无法找到一个将被发现的保证。
    
    参数
    
    a -阵列被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它是包含在数组；否则， (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素大于：关键指标，或 a.length如果数组中的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
  - binarySearch
```
public static int binarySearch(long[] a,
                               int fromIndex,
                               int toIndex,
                               long key)
```
    使用二进制搜索算法搜索指定的指定值的指定数组的范围。范围必须排序（由 sort(long[], int, int)法）进行调用之前。如果它没有排序，结果是不确定的。如果该范围包含具有指定值的多个元素，则无法找到一个将被发现的保证。
    
    参数
    
    a -阵列被搜查
    
    fromIndex -第一个元素的索引（含）被搜查
    
    toIndex -最后一个元素的索引（独家）被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它包含在指定范围内的阵列；否则， (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素的索引：在范围大于键，或 toIndex如果在范围内的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    如果 fromIndex < 0 or toIndex > a.length ArrayIndexOutOfBoundsException
    
    从以下版本开始：
    
    一点六
  - binarySearch
```
public static int binarySearch(int[] a,
                               int key)
```
    搜索指定的数组中的值指定的值使用二进制搜索算法。数组必须排序（由 sort(int[])法）进行调用之前。如果它没有排序，结果是不确定的。如果数组包含具有指定值的多个元素，则无法找到一个将被发现的保证。
    
    参数
    
    a -阵列被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它是包含在数组；否则， (-(insertion point) - 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 -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它包含在指定范围内的阵列；否则， (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素的索引：在范围大于键，或 toIndex如果在范围内的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    如果 fromIndex < 0 or toIndex > a.length ArrayIndexOutOfBoundsException
    
    从以下版本开始：
    
    一点六
  - binarySearch
```
public static int binarySearch(short[] a,
                               short key)
```
    使用二进制搜索算法搜索指定值的指定数组的短裤。数组必须排序（由 sort(short[])法）进行调用之前。如果它没有排序，结果是不确定的。如果数组包含具有指定值的多个元素，则无法找到一个将被发现的保证。
    
    参数
    
    a -阵列被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它是包含在数组；否则， (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素大于：关键指标，或 a.length如果数组中的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
  - binarySearch
```
public static int binarySearch(short[] a,
                               int fromIndex,
                               int toIndex,
                               short key)
```
    使用二进制搜索算法搜索指定值的指定数组的范围。范围必须排序（由 sort(short[], int, int)法）进行调用之前。如果它没有排序，结果是不确定的。如果该范围包含具有指定值的多个元素，则无法找到一个将被发现的保证。
    
    参数
    
    a -阵列被搜查
    
    fromIndex -第一个元素的索引（含）被搜查
    
    toIndex -最后一个元素的索引（独家）被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它包含在指定范围内的阵列；否则， (-(insertion point) - 1)，插入点被定义为在该点的关键是插入到数组的第一个元素的索引：在范围大于键，或 toIndex如果在范围内的所有元素少比指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    如果 fromIndex < 0 or toIndex > a.length ArrayIndexOutOfBoundsException
    
    从以下版本开始：
    
    一点六
  - binarySearch
```
public static int binarySearch(char[] a,
                               char key)
```
    搜索指定的字符数组的指定值使用二进制搜索算法。数组必须排序（由 sort(char[])法）进行调用之前。如果它没有排序，结果是不确定的。如果数组包含具有指定值的多个元素，则无法找到一个将被发现的保证。
    
    参数
    
    a -阵列被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它是包含在数组；否则， (-(insertion point) - 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 -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它包含在指定范围内的阵列；否则， (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素的索引：在范围大于键，或 toIndex如果在范围内的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    如果 fromIndex < 0 or toIndex > a.length ArrayIndexOutOfBoundsException
    
    从以下版本开始：
    
    一点六
  - binarySearch
```
public static int binarySearch(byte[] a,
                               byte key)
```
    使用二进制搜索算法搜索指定的值的字节数组。数组必须排序（由 sort(byte[])法）进行调用之前。如果它没有排序，结果是不确定的。如果数组包含具有指定值的多个元素，则无法找到一个将被发现的保证。
    
    参数
    
    a -阵列被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它是包含在数组；否则， (-(insertion point) - 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 -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它包含在指定范围内的阵列；否则， (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素的索引：在范围大于键，或 toIndex如果在范围内的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    如果 fromIndex < 0 or toIndex > a.length ArrayIndexOutOfBoundsException
    
    从以下版本开始：
    
    一点六
  - binarySearch
```
public static int binarySearch(double[] a,
                               double key)
```
    使用二进制搜索算法搜索指定值的指定数组。数组必须排序（由 sort(double[])法）进行调用之前。如果它没有排序，结果是不确定的。如果数组包含具有指定值的多个元素，则无法找到一个将被发现的保证。这种方法认为所有的南值是等价的和平等的。
    
    参数
    
    a -阵列被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它是包含在数组；否则， (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素大于：关键指标，或 a.length如果数组中的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
  - binarySearch
```
public static int binarySearch(double[] a,
                               int fromIndex,
                               int toIndex,
                               double key)
```
    使用二进制搜索算法搜索指定值的指定数组的范围。范围必须排序（由 sort(double[], int, int)法）进行调用之前。如果它没有排序，结果是不确定的。如果该范围包含具有指定值的多个元素，则无法找到一个将被发现的保证。这种方法认为所有的南值是等价的和平等的。
    
    参数
    
    a -阵列被搜查
    
    fromIndex -第一个元素的索引（含）被搜查
    
    toIndex -最后一个元素的索引（独家）被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它包含在指定范围内的阵列；否则， (-(insertion point) - 1)，插入点被定义为在该点的关键是插入到数组的第一个元素的索引：在范围大于键，或 toIndex如果在范围内的所有元素少比指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    如果 fromIndex < 0 or toIndex > a.length ArrayIndexOutOfBoundsException
    
    从以下版本开始：
    
    一点六
  - binarySearch
```
public static int binarySearch(float[] a,
                               float key)
```
    使用二进制搜索算法在指定值中搜索指定的浮点数组。数组必须排序（由 sort(float[])法）进行调用之前。如果它没有排序，结果是不确定的。如果数组包含具有指定值的多个元素，则无法找到一个将被发现的保证。这种方法认为所有的南值是等价的和平等的。
    
    参数
    
    a -阵列被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它是包含在数组；否则， (-(insertion point) - 1)，插入点被定义为在该点的关键是插入到数组的第一个元素大于：关键指标，或 a.length如果数组中的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
  - binarySearch
```
public static int binarySearch(float[] a,
                               int fromIndex,
                               int toIndex,
                               float key)
```
    使用二进制搜索算法搜索指定值的指定数组的范围。范围必须排序（由 sort(float[], int, int)法）进行调用之前。如果它没有排序，结果是不确定的。如果该范围包含具有指定值的多个元素，则无法找到一个将被发现的保证。这种方法认为所有的南值是等价的和平等的。
    
    参数
    
    a -阵列被搜查
    
    fromIndex -第一个元素的索引（含）被搜查
    
    toIndex -最后一个元素的索引（独家）被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它包含在指定范围内的阵列；否则， (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素的索引：在范围大于键，或 toIndex如果在范围内的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    如果 fromIndex < 0 or toIndex > a.length ArrayIndexOutOfBoundsException
    
    从以下版本开始：
    
    一点六
  - binarySearch
```
public static int binarySearch(Object[] a,
                               Object key)
```
    使用二进制搜索算法在指定的对象中搜索指定的数组。数组必须排序为升序按其元素的 natural ordering（由 sort(Object[])法）进行调用之前。如果它没有排序，结果是不确定的。（如果数组中包含不可相互比较的元素（例如，字符串和整数），它不能根据元素的自然顺序排序，因此结果是未定义的。）如果数组包含多个元素等于指定的对象，也不能保证哪一个会被发现。
    
    参数
    
    a -阵列被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它是包含在数组；否则， (-(insertion point) - 1)，插入点被定义为在该点的关键是插入到数组的第一个元素大于：关键指标，或 a.length如果数组中的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
    
    异常
    
    ClassCastException -如果搜索关键是没有可比性的元素的数组。
  - binarySearch
```
public static int binarySearch(Object[] a,
                               int fromIndex,
                               int toIndex,
                               Object key)
```
    使用二进制搜索算法搜索指定对象的指定数组的范围。范围必须按升序排列根据其元素的 natural ordering（由 sort(Object[], int, int)法）进行调用之前。如果它没有排序，结果是不确定的。（如果范围包含不可相互比较的元素（例如，字符串和整数），它不能根据元素的自然顺序排序，因此结果是未定义的。）如果包含多个元素等于指定的对象，也不能保证哪一个会被发现。
    
    参数
    
    a -阵列被搜查
    
    fromIndex -第一个元素的索引（含）被搜查
    
    toIndex -最后一个元素的索引（独家）被搜查
    
    key -要搜索的价值
    
    结果
    
    索引的搜索关键字，如果它包含在指定范围内的阵列；否则， (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素的索引：在范围大于键，或 toIndex如果在范围内的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
    
    异常
    
    ClassCastException -如果搜索关键是没有可比性，对指定范围内的数组元素。
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    如果 fromIndex < 0 or toIndex > a.length ArrayIndexOutOfBoundsException
    
    从以下版本开始：
    
    一点六
  - binarySearch
```
public static <T> int binarySearch(T[] a,
                                   T key,
                                   Comparator<? super T> c)
```
    使用二进制搜索算法在指定的对象中搜索指定的数组。数组必须排序为升序按指定的比较器（由 sort(T[], Comparator)法）进行调用之前。如果它没有排序，结果是不确定的。如果数组包含等于指定对象的多个元素，则将无法找到一个将被发现的保证。
    
    参数类型
    
    T -数组中对象的类
    
    参数
    
    a -阵列被搜查
    
    key -要搜索的价值
    
    c -比较器的数组排序。一个 null值表示元素的 natural ordering应使用。
    
    结果
    
    索引的搜索关键字，如果它是包含在数组；否则， (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素大于：关键指标，或 a.length如果数组中的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
    
    异常
    
    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 -比较器的数组排序。一个 null值表示元素的 natural ordering应使用。
    
    结果
    
    索引的搜索关键字，如果它包含在指定范围内的阵列；否则， (-(insertion point) - 1)，插入点被定义为在该点的关键是插入到数组的第一个元素的索引：在范围大于键，或 toIndex如果在范围内的所有元素少比指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。
    
    异常
    
    ClassCastException -如果范围包含不相互比较使用指定的比较器的元素，或搜索的关键是比不使用这个比较器的范围内的元素。
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    如果 fromIndex < 0 or toIndex > a.length ArrayIndexOutOfBoundsException
    
    从以下版本开始：
    
    一点六
  - equals
```
public static boolean equals(long[] a,
                             long[] a2)
```
    返回 true如果两个指定阵列的渴望是平等的彼此。两个数组被认为是相等的，如果两个数组包含相同数量的元素，和在两个数组中的所有对应的元素是相等的。换句话说，两个数组是相等的，如果它们包含相同的顺序中的相同的元素。另外，两数组引用如果都是 null是相同的。
    
    参数
    
    a一阵列进行平等
    
    a2 -去进行平等的其他阵列
    
    结果
    
    true如果两个数组都是平等的
  - equals
```
public static boolean equals(int[] a,
                             int[] a2)
```
    返回 true如果两个指定的int数组是一平等的。两个数组被认为是相等的，如果两个数组包含相同数量的元素，和在两个数组中的所有对应的元素是相等的。换句话说，两个数组是相等的，如果它们包含相同的顺序中的相同的元素。另外，两数组引用如果都是 null是相同的。
    
    参数
    
    a一阵列进行平等
    
    a2 -去进行平等的其他阵列
    
    结果
    
    true如果两个数组都是平等的
  - equals
```
public static boolean equals(short[] a,
                             short[] a2)
```
    返回 true如果两个指定阵列的短裤是平等的彼此。两个数组被认为是相等的，如果两个数组包含相同数量的元素，和在两个数组中的所有对应的元素是相等的。换句话说，两个数组是相等的，如果它们包含相同的顺序中的相同的元素。另外，两数组引用如果都是 null视为相等。
    
    参数
    
    a一阵列进行平等
    
    a2 -去进行平等的其他阵列
    
    结果
    
    true如果两个数组都是平等的
  - equals
```
public static boolean equals(char[] a,
                             char[] a2)
```
    返回 true如果两个指定字符数组平等的彼此。两个数组被认为是相等的，如果两个数组包含相同数量的元素，和在两个数组中的所有对应的元素是相等的。换句话说，两个数组是相等的，如果它们包含相同的顺序中的相同的元素。另外，两数组引用如果都是 null视为相等。
    
    参数
    
    a一阵列进行平等
    
    a2 -去进行平等的其他阵列
    
    结果
    
    true如果两个数组都是平等的
  - equals
```
public static boolean equals(byte[] a,
                             byte[] a2)
```
    返回 true如果两个指定的字节数组是一平等的。两个数组被认为是相等的，如果两个数组包含相同数量的元素，和在两个数组中的所有对应的元素是相等的。换句话说，两个数组是相等的，如果它们包含相同的顺序中的相同的元素。另外，两数组引用如果都是 null视为相等。
    
    参数
    
    a一阵列进行平等
    
    a2 -去进行平等的其他阵列
    
    结果
    
    true如果两个数组都是平等的
  - equals
```
public static boolean equals(boolean[] a,
                             boolean[] a2)
```
    返回 true如果两个指定阵列的布尔值平等的彼此。两个数组被认为是相等的，如果两个数组包含相同数量的元素，和在两个数组中的所有对应的元素是相等的。换句话说，两个数组是相等的，如果它们包含相同的顺序中的相同的元素。另外，两数组引用如果都是 null视为相等。
    
    参数
    
    a一阵列进行平等
    
    a2 -去进行平等的其他阵列
    
    结果
    
    true如果两个数组都是平等的
  - equals
```
public static boolean equals(double[] a,
                             double[] a2)
```
    返回指定数组 true如果两双打都平等的彼此。两个数组被认为是相等的，如果两个数组包含相同数量的元素，和在两个数组中的所有对应的元素是相等的。换句话说，两个数组是相等的，如果它们包含相同的顺序中的相同的元素。另外，两数组引用如果都是 null是相同的。
    两双打d1和d2都是相同的如果：
```
new Double(d1).equals(new Double(d2))
```
    （不像 ==算子，该方法考虑 NaN等于本身，和0.0d - 0.0d不等。）
    参数
    
    a一阵列进行平等
    
    a2 -去进行平等的其他阵列
    
    结果
    
    true如果两个数组都是平等的
    
    另请参见：
    
    Double.equals(Object)
  - equals
```
public static boolean equals(float[] a,
                             float[] a2)
```
    返回 true如果两个指定阵列的浮动平等的彼此。两个数组被认为是相等的，如果两个数组包含相同数量的元素，和在两个数组中的所有对应的元素是相等的。换句话说，两个数组是相等的，如果它们包含相同的顺序中的相同的元素。另外，两数组引用如果都是 null视为相等。
    两浮f1和f2都是相同的如果：
```
new Float(f1).equals(new Float(f2))
```
    （不像 ==算子，该方法考虑 NaN等于本身，和0.0f不等- 0.0f。）
    参数
    
    a一阵列进行平等
    
    a2 -去进行平等的其他阵列
    
    结果
    
    true如果两个数组都是平等的
    
    另请参见：
    
    Float.equals(Object)
  - equals
```
public static boolean equals(Object[] a,
                             Object[] a2)
```
    返回 true如果两个指定对象数组是平等的彼此。两个数组被认为是相等的，如果两个数组包含相同数量的元素，和在两个数组中的所有对应的元素是相等的。两个对象 e1和 e2是平等的如果 (e1==null ? e2==null : e1.equals(e2))。换句话说，两个数组是相等的，如果它们包含相同的顺序中的相同的元素。另外，两数组引用如果都是 null是相同的。
    
    参数
    
    a一阵列进行平等
    
    a2 -去进行平等的其他阵列
    
    结果
    
    true如果两个数组都是平等的
  - fill
```
public static void fill(long[] a,
                        long val)
```
    将指定的长值分配给指定数组的每个元素的值。
    
    参数
    
    a -数组填充
    
    val -被存储在数组的所有元素的值
  - fill
```
public static void fill(long[] a,
                        int fromIndex,
                        int toIndex,
                        long val)
```
    将指定的长值分配给指定数组的指定数组的每个元素的值。范围是从指数 fromIndex填充，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex，范围是满是空的。）
    
    参数
    
    a -数组填充
    
    fromIndex -第一个元素的索引（含）充满指定值
    
    toIndex -最后一个元素的索引（独家）充满指定值
    
    val -被存储在数组的所有元素的值
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(int[] a,
                        int val)
```
    将指定的int值来指定数组的每个元素的值。
    
    参数
    
    a -数组填充
    
    val -被存储在数组的所有元素的值
  - fill
```
public static void fill(int[] a,
                        int fromIndex,
                        int toIndex,
                        int val)
```
    将指定的int值为指定数组的每个元素对象的指定范围。范围是从指数 fromIndex填充，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex，范围是满是空的。）
    
    参数
    
    a -数组填充
    
    fromIndex -第一个元素的索引（含）充满指定值
    
    toIndex -最后一个元素的索引（独家）充满指定值
    
    val -被存储在数组的所有元素的值
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(short[] a,
                        short val)
```
    将指定的短值分配给指定数组的每个元素的。
    
    参数
    
    a -数组填充
    
    val -被存储在数组的所有元素的值
  - fill
```
public static void fill(short[] a,
                        int fromIndex,
                        int toIndex,
                        short val)
```
    将指定的短值分配给指定数组的指定数组的每个元素的值。范围是从指数 fromIndex填充，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex，范围是满是空的。）
    
    参数
    
    a -数组填充
    
    fromIndex -第一个元素的索引（含）充满指定值
    
    toIndex -最后一个元素的索引（独家）充满指定值
    
    val -被存储在数组的所有元素的值
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(char[] a,
                        char val)
```
    将指定的字符值为指定的字符数组的每个元素。
    
    参数
    
    a -数组填充
    
    val -被存储在数组的所有元素的值
  - fill
```
public static void fill(char[] a,
                        int fromIndex,
                        int toIndex,
                        char val)
```
    将指定的字符值为指定的字符数组的指定范围内的每个元素。范围是从指数 fromIndex填充，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex，范围是满是空的。）
    
    参数
    
    a -数组填充
    
    fromIndex -第一个元素的索引（含）充满指定值
    
    toIndex -最后一个元素的索引（独家）充满指定值
    
    val -被存储在数组的所有元素的值
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    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)
```
    将指定的字节值分配给指定的字节数组的指定范围的每个元素。范围是从指数 fromIndex填充，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex，范围是满是空的。）
    
    参数
    
    a -数组填充
    
    fromIndex -第一个元素的索引（含）充满指定值
    
    toIndex -最后一个元素的索引（独家）充满指定值
    
    val -被存储在数组的所有元素的值
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    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)
```
    将指定的布尔值来指定数组的每个元素的布尔值指定的范围。范围是从指数 fromIndex填充，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex，范围是满是空的。）
    
    参数
    
    a -数组填充
    
    fromIndex -第一个元素的索引（含）充满指定值
    
    toIndex -最后一个元素的索引（独家）充满指定值
    
    val -被存储在数组的所有元素的值
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(double[] a,
                        double val)
```
    将指定的双值分配给指定数组的每个元素的两个元素。
    
    参数
    
    a -数组填充
    
    val -被存储在数组的所有元素的值
  - fill
```
public static void fill(double[] a,
                        int fromIndex,
                        int toIndex,
                        double val)
```
    将指定的双值分配给指定数组的指定数组的每个元素的指定范围内的每个元素。范围是从指数 fromIndex填充，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex，范围是满是空的。）
    
    参数
    
    a -数组填充
    
    fromIndex -第一个元素的索引（含）充满指定值
    
    toIndex -最后一个元素的索引（独家）充满指定值
    
    val -被存储在数组的所有元素的值
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    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)
```
    将指定的浮点值分配给指定的浮点数组的指定范围的每个元素。范围是从指数 fromIndex填充，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex，范围是满是空的。）
    
    参数
    
    a -数组填充
    
    fromIndex -第一个元素的索引（含）充满指定值
    
    toIndex -最后一个元素的索引（独家）充满指定值
    
    val -被存储在数组的所有元素的值
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
  - fill
```
public static void fill(Object[] a,
                        Object val)
```
    将指定的对象引用分配给指定的对象数组的每个元素。
    
    参数
    
    a -数组填充
    
    val -被存储在数组的所有元素的值
    
    异常
    
    ArrayStoreException -如果指定的值不是一个运行时类型可以存储在指定的数组
  - fill
```
public static void fill(Object[] a,
                        int fromIndex,
                        int toIndex,
                        Object val)
```
    将指定的对象引用分配给指定的对象数组的指定范围的每个元素。范围是从指数 fromIndex填充，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex，范围是满是空的。）
    
    参数
    
    a -数组填充
    
    fromIndex -第一个元素的索引（含）充满指定值
    
    toIndex -最后一个元素的索引（独家）充满指定值
    
    val -被存储在数组的所有元素的值
    
    异常
    
    如果 fromIndex > toIndex IllegalArgumentException
    
    ArrayIndexOutOfBoundsException -如果 fromIndex < 0或 toIndex > a.length
    
    ArrayStoreException -如果指定的值不是一个运行时类型可以存储在指定的数组
  - copyOf
```
public static <T> T[] copyOf(T[] original,
                             int newLength)
```
    复制指定的数组，截断或填充空值（如果需要）所以副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，两个数组将包含相同的值。任何指标，有效的复制而不是原来的副本将包含 null。这样的索引将存在，如果和只有当指定的长度大于原来的阵列。将得到的数组与原来的数组是完全相同的。
    
    参数类型
    
    T -数组中对象的类
    
    参数
    
    original -数组被复制
    
    newLength -要返回的副本的长度
    
    结果
    
    一份原始数组，截断或软垫陷到规定的长度
    
    异常
    
    NegativeArraySizeException -如果 newLength是负的
    
    NullPointerException -如果 original是空的
    
    从以下版本开始：
    
    一点六
  - copyOf
```
public static <T,U> T[] copyOf(U[] original,
                               int newLength,
                               类<? extends T[]> newType)
```
    复制指定的数组，截断或填充空值（如果需要）所以副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，两个数组将包含相同的值。任何指标，有效的复制而不是原来的副本将包含 null。这样的索引将存在，如果和只有当指定的长度大于原来的阵列。结果数组类的 newType。
    
    参数类型
    
    U -原始数组中的对象的类
    
    T -返回数组中的对象的类
    
    参数
    
    original -数组被复制
    
    newLength -要返回的副本的长度
    
    newType -复制回班
    
    结果
    
    一份原始数组，截断或软垫陷到规定的长度
    
    异常
    
    NegativeArraySizeException -如果 newLength是负的
    
    NullPointerException -如果 original是空的
    
    ArrayStoreException如果从 original复制元素不是一个运行时类型可以存储在一个数组的类 newType
    
    从以下版本开始：
    
    一点六
  - copyOf
```
public static byte[] copyOf(byte[] original,
                            int newLength)
```
    复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，两个数组将包含相同的值。任何指标，有效的复制而不是原来的副本将包含 (byte)0。该指数将只有指定的长度大于原始数组的存在。
    
    参数
    
    original -数组被复制
    
    newLength -要返回的副本的长度
    
    结果
    
    原始数组的一个副本，截断或用0填充，以获得指定的长度
    
    异常
    
    NegativeArraySizeException -如果 newLength是负的
    
    NullPointerException -如果 original是空的
    
    从以下版本开始：
    
    一点六
  - copyOf
```
public static short[] copyOf(short[] original,
                             int newLength)
```
    复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，两个数组将包含相同的值。任何指标，有效的复制而不是原来的副本将包含 (short)0。这样的索引将存在，如果和只有当指定的长度大于原来的阵列。
    
    参数
    
    original -数组被复制
    
    newLength -要返回的副本的长度
    
    结果
    
    原始数组的一个副本，截断或用0填充，以获得指定的长度
    
    异常
    
    NegativeArraySizeException -如果 newLength是负的
    
    NullPointerException -如果 original是空的
    
    从以下版本开始：
    
    一点六
  - copyOf
```
public static int[] copyOf(int[] original,
                           int newLength)
```
    复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，两个数组将包含相同的值。任何指标，有效的复制而不是原来的副本将包含 0。该指数将只有指定的长度大于原始数组的存在。
    
    参数
    
    original -数组被复制
    
    newLength -要返回的副本的长度
    
    结果
    
    原始数组的一个副本，截断或用0填充，以获得指定的长度
    
    异常
    
    NegativeArraySizeException -如果 newLength是负的
    
    NullPointerException -如果 original是空的
    
    从以下版本开始：
    
    一点六
  - copyOf
```
public static long[] copyOf(long[] original,
                            int newLength)
```
    复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，两个数组将包含相同的值。任何指标，有效的复制而不是原来的副本将包含 0L。该指数将只有指定的长度大于原始数组的存在。
    
    参数
    
    original -数组被复制
    
    newLength -要返回的副本的长度
    
    结果
    
    原始数组的一个副本，截断或用0填充，以获得指定的长度
    
    异常
    
    NegativeArraySizeException -如果 newLength是负的
    
    NullPointerException -如果 original是空的
    
    从以下版本开始：
    
    一点六
  - copyOf
```
public static char[] copyOf(char[] original,
                            int newLength)
```
    复制指定的数组，截断或空字符填充（如果必要）所以副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，两个数组将包含相同的值。任何指标，有效的复制而不是原来的副本将包含 '\\u000'。这样的索引将存在，如果和只有当指定的长度大于原来的阵列。
    
    参数
    
    original -数组被复制
    
    newLength -要返回的副本的长度
    
    结果
    
    原始数组的一个副本，用空字符截断或填充，以获得指定的长度
    
    异常
    
    NegativeArraySizeException -如果 newLength是负的
    
    NullPointerException -如果 original是空的
    
    从以下版本开始：
    
    一点六
  - copyOf
```
public static float[] copyOf(float[] original,
                             int newLength)
```
    复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，两个数组将包含相同的值。任何指标，有效的复制而不是原来的副本将包含 0f。这样的索引将存在，如果和只有当指定的长度大于原来的阵列。
    
    参数
    
    original -数组被复制
    
    newLength -要返回的副本的长度
    
    结果
    
    原始数组的一个副本，截断或用0填充，以获得指定的长度
    
    异常
    
    NegativeArraySizeException -如果 newLength是负的
    
    NullPointerException -如果 original是空的
    
    从以下版本开始：
    
    一点六
  - copyOf
```
public static double[] copyOf(double[] original,
                              int newLength)
```
    复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，两个数组将包含相同的值。任何指标，有效的复制而不是原来的副本将包含 0d。这样的索引将存在，如果和只有当指定的长度大于原来的阵列。
    
    参数
    
    original -数组被复制
    
    newLength -要返回的副本的长度
    
    结果
    
    原始数组的一个副本，截断或用0填充，以获得指定的长度
    
    异常
    
    NegativeArraySizeException -如果 newLength是负的
    
    NullPointerException -如果 original是空的
    
    从以下版本开始：
    
    一点六
  - copyOf
```
public static boolean[] copyOf(boolean[] original,
                               int newLength)
```
    复制指定的数组，截断或填充 false（如果必要）所以副本具有指定的长度。对于在原始数组和副本中都有效的所有索引，两个数组将包含相同的值。任何指标，有效的复制而不是原来的副本将包含 false。这样的索引将存在，如果和只有当指定的长度大于原来的阵列。
    
    参数
    
    original -数组被复制
    
    newLength -要返回的副本的长度
    
    结果
    
    一个原始数组的副本，截断或填充虚假元素，以获得指定的长度
    
    异常
    
    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.length - from所有元素。返回的数组的长度将 to - from。
    将得到的数组与原来的数组是完全相同的。
    
    参数类型
    
    T -数组中对象的类
    
    参数
    
    original -阵列从一个范围是可复制的
    
    from -的范围内被复制的初始指标，包括
    
    to -的范围内被复制的最终指标，独家。（此索引可能位于数组之外。）
    
    结果
    
    一个新的数组包含指定的范围从原来的阵列，截断或填充空值来获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 from < 0或 from > original.length
    
    如果 from > to IllegalArgumentException
    
    NullPointerException -如果 original是空的
    
    从以下版本开始：
    
    一点六
  - copyOfRange
```
public static <T,U> T[] copyOfRange(U[] original,
                                    int from,
                                    int to,
                                    类<? extends T[]> newType)
```
    将指定的数组指定的范围复制到一个新的数组中。该范围的初始指标（ from）必须是零和 original.length之间，包容。在 original[from]价值置于副本的初始元（除非 from == original.length或 from == to）。从原始数组中的后续元素的值被放置到副本中的后续元素中。该范围的最终指标（ to），它必须大于或等于 from，可能要比 original.length，在这种情况下， null放置在复制的指数大于或等于 original.length - from所有元素。返回的数组的长度将 to - from。结果数组类的 newType。
    
    参数类型
    
    U -原始数组中的对象的类
    
    T -返回数组中的对象的类
    
    参数
    
    original -阵列从一个范围是可复制的
    
    from -的范围内被复制的初始指标，包括
    
    to -的范围内被复制的最终指标，独家。（此索引可能位于数组之外。）
    
    newType -复制回班
    
    结果
    
    一个新的数组包含指定的范围从原来的阵列，截断或填充空值来获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 from < 0或 from > original.length
    
    如果 from > to IllegalArgumentException
    
    NullPointerException -如果 original是空的
    
    ArrayStoreException如果从 original复制元素不是一个运行时类型可以存储在一个数组的类 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 - from所有元素。返回的数组的长度将 to - from。
    
    参数
    
    original -阵列从一个范围是可复制的
    
    from -的范围内被复制的初始指标，包括
    
    to -的范围内被复制的最终指标，独家。（此索引可能位于数组之外。）
    
    结果
    
    一个新的数组，包含指定的范围从原来的数组，截断或填充与零，以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 from < 0或 from > original.length
    
    如果 from > to IllegalArgumentException
    
    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 - from所有元素。返回的数组的长度将 to - from。
    
    参数
    
    original -阵列从一个范围是可复制的
    
    from -的范围内被复制的初始指标，包括
    
    to -的范围内被复制的最终指标，独家。（此索引可能位于数组之外。）
    
    结果
    
    一个新的数组，包含指定的范围从原来的数组，截断或填充与零，以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 from < 0或 from > original.length
    
    如果 from > to IllegalArgumentException
    
    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.length - from所有元素。返回的数组的长度将 to - from。
    
    参数
    
    original -阵列从一个范围是可复制的
    
    from -的范围内被复制的初始指标，包括
    
    to -的范围内被复制的最终指标，独家。（此索引可能位于数组之外。）
    
    结果
    
    一个新的数组，包含指定的范围从原来的数组，截断或填充与零，以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 from < 0或 from > original.length
    
    如果 from > to IllegalArgumentException
    
    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.length - from所有元素。返回的数组的长度将 to - from。
    
    参数
    
    original -阵列从一个范围是可复制的
    
    from -的范围内被复制的初始指标，包括
    
    to -的范围内被复制的最终指标，独家。（此索引可能位于数组之外。）
    
    结果
    
    一个新的数组，包含指定的范围从原来的数组，截断或填充与零，以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 from < 0或 from > original.length
    
    如果 from > to IllegalArgumentException
    
    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 - from元素。返回的数组的长度将 to - from。
    
    参数
    
    original -阵列从一个范围是可复制的
    
    from -的范围内被复制的初始指标，包括
    
    to -的范围内被复制的最终指标，独家。（此索引可能位于数组之外。）
    
    结果
    
    一个新的数组，包含指定的范围从原来的数组，截断或填充空字符，以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 from < 0或 from > original.length
    
    如果 from > to IllegalArgumentException
    
    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.length - from所有元素。返回的数组的长度将 to - from。
    
    参数
    
    original -阵列从一个范围是可复制的
    
    from -的范围内被复制的初始指标，包括
    
    to -的范围内被复制的最终指标，独家。（此索引可能位于数组之外。）
    
    结果
    
    一个新的数组，包含指定的范围从原来的数组，截断或填充与零，以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 from < 0或 from > original.length
    
    如果 from > to IllegalArgumentException
    
    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.length - from元素。返回的数组的长度将 to - from。
    
    参数
    
    original -阵列从一个范围是可复制的
    
    from -的范围内被复制的初始指标，包括
    
    to -的范围内被复制的最终指标，独家。（此索引可能位于数组之外。）
    
    结果
    
    一个新的数组，包含指定的范围从原来的数组，截断或填充与零，以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 from < 0或 from > original.length
    
    如果 from > to IllegalArgumentException
    
    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.length - from元素。返回的数组的长度将 to - from。
    
    参数
    
    original -阵列从一个范围是可复制的
    
    from -的范围内被复制的初始指标，包括
    
    to -的范围内被复制的最终指标，独家。（此索引可能位于数组之外。）
    
    结果
    
    一个新的数组，包含指定的范围从原来的数组，截断或填充的假元素，以获得所需的长度
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 from < 0或 from > original.length
    
    如果 from > to IllegalArgumentException
    
    NullPointerException -如果 original是空的
    
    从以下版本开始：
    
    一点六
  - asList
```
@SafeVarargs
public static <T> List<T> asList(T... a)
```
    返回由指定数组支持的一个固定大小的列表。（改变返回列表“写”到数组。）该方法作为基于阵列和基于集合API之间的桥梁，结合 Collection.toArray()。返回的列表是可序列化的实现 RandomAccess。
    此方法还提供了一个方便的方法来创建一个初始化为包含多个元素的固定大小列表：
```
列表
 
            
            
            
          
            
          <字符串>
           
             
           
             
             
             
  傀儡=阵列。asList（“拉里”、“萌”、“曲”）；
 
            
            
            
          
            
          
```
    参数类型
    
    T -数组中对象的类
    
    参数
    
    a -数组，列表会支持
    
    结果
    
    指定数组的列表视图
  - hashCode
```
public static int hashCode(long[] a)
```
    返回基于指定数组的内容的哈希代码。任何两 long阵列 a和 b这样 Arrays.equals(a, b)，也正是如此， Arrays.hashCode(a) == Arrays.hashCode(b)。
    此方法返回的值是可以通过调用一个List包含一系列的Long实例表示在同一顺序的a元素的hashCode方法得到相同的值。如果a是null，此方法返回0。
    
    参数
    
    a -数组的散列值的计算
    
    结果
    
    基于内容的哈希代码 a
    
    从以下版本开始：
    
    一点五
  - hashCode
```
public static int hashCode(int[] a)
```
    返回基于指定数组的内容的哈希代码。对任意两个非零 int阵列 a和 b这样 Arrays.equals(a, b)，也正是如此， Arrays.hashCode(a) == Arrays.hashCode(b)。
    此方法返回的值是可以通过调用一个List包含一系列的Integer实例表示在同一顺序的a元素的hashCode方法得到相同的值。如果a是null，此方法返回0。
    
    参数
    
    a -数组的散列值的计算
    
    结果
    
    基于内容的哈希代码 a
    
    从以下版本开始：
    
    一点五
  - hashCode
```
public static int hashCode(short[] a)
```
    返回基于指定数组的内容的哈希代码。任何两 short阵列 a和 b这样 Arrays.equals(a, b)，也正是如此， Arrays.hashCode(a) == Arrays.hashCode(b)。
    此方法返回的值是可以通过调用一个List包含一系列的Short实例表示在同一顺序的a元素的hashCode方法得到相同的值。如果a是null，此方法返回0。
    
    参数
    
    a -数组的散列值的计算
    
    结果
    
    基于内容的哈希代码 a
    
    从以下版本开始：
    
    一点五
  - hashCode
```
public static int hashCode(char[] a)
```
    返回基于指定数组的内容的哈希代码。任何两 char阵列 a和 b这样 Arrays.equals(a, b)，也正是如此， Arrays.hashCode(a) == Arrays.hashCode(b)。
    此方法返回的值是可以通过调用一个List包含一系列的Character实例表示在同一顺序的a元素的hashCode方法得到相同的值。如果a是null，此方法返回0。
    
    参数
    
    a -数组的散列值的计算
    
    结果
    
    基于内容的哈希代码 a
    
    从以下版本开始：
    
    一点五
  - hashCode
```
public static int hashCode(byte[] a)
```
    返回基于指定数组的内容的哈希代码。任何两 byte阵列 a和 b这样 Arrays.equals(a, b)，也正是如此， Arrays.hashCode(a) == Arrays.hashCode(b)。
    此方法返回的值是可以通过调用一个List包含一系列的Byte实例表示在同一顺序的a元素的hashCode方法得到相同的值。如果a是null，此方法返回0。
    
    参数
    
    a -数组的散列值的计算
    
    结果
    
    基于内容的哈希代码 a
    
    从以下版本开始：
    
    一点五
  - hashCode
```
public static int hashCode(boolean[] a)
```
    返回基于指定数组的内容的哈希代码。任何两 boolean阵列 a和 b这样 Arrays.equals(a, b)，也正是如此， Arrays.hashCode(a) == Arrays.hashCode(b)。
    此方法返回的值是可以通过调用一个List包含一系列的Boolean实例表示在同一顺序的a元素的hashCode方法得到相同的值。如果a是null，此方法返回0。
    
    参数
    
    a -数组的散列值的计算
    
    结果
    
    基于内容的哈希代码 a
    
    从以下版本开始：
    
    一点五
  - hashCode
```
public static int hashCode(float[] a)
```
    返回基于指定数组的内容的哈希代码。任何两 float阵列 a和 b这样 Arrays.equals(a, b)，也正是如此， Arrays.hashCode(a) == Arrays.hashCode(b)。
    此方法返回的值是可以通过调用一个List包含一系列的Float实例表示在同一顺序的a元素的hashCode方法得到相同的值。如果a是null，此方法返回0。
    
    参数
    
    a -数组的散列值的计算
    
    结果
    
    基于内容的哈希代码 a
    
    从以下版本开始：
    
    一点五
  - hashCode
```
public static int hashCode(double[] a)
```
    返回基于指定数组的内容的哈希代码。任何两 double阵列 a和 b这样 Arrays.equals(a, b)，也正是如此， Arrays.hashCode(a) == Arrays.hashCode(b)。
    此方法返回的值是可以通过调用一个List包含一系列的Double实例表示在同一顺序的a元素的hashCode方法得到相同的值。如果a是null，此方法返回0。
    
    参数
    
    a -数组的散列值的计算
    
    结果
    
    基于内容的哈希代码 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 -数组的内容的哈希码的计算
    
    结果
    
    基于内容的哈希代码 a
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    deepHashCode(Object[])
  - 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是参考阵列NCE型。如果a是null，此方法返回0。
    
    参数
    
    a -阵列其深层的基于内容的哈希码的计算
    
    结果
    
    一种基于哈希代码 a深度内容
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    hashCode(Object[])
  - deepEquals
```
public static boolean deepEquals(Object[] a1,
                                 Object[] a2)
```
    返回指定数组 true如果两深深的平等彼此。不像 equals(Object[],Object[])方法，该方法适用于任意深度的嵌套数组。
    两个数组引用如果都是null深刻考虑平等，或者如果他们指的是含有相同数量的元素的数组和两个数组中的元素都对应地相等。
    
    如果下列条件举行两可能null元素e1和e2深感平等：
    - e1和e2是对象引用类型的数组，并Arrays.deepEquals(e1, e2) would return true
    - e1和e2是相同的原始类型的数组，并适当超载Arrays.equals(e1, e2)将返回true。
    - e1 == e2
    - e1.equals(e2)将返回true。
    注意这个定义允许 null元素在任何深度。
    如果指定的数组中的任一个都包含直接或间接地通过一个或多个数组的元素，这种方法的行为是不确定的。
    参数
    
    a1一阵列进行平等
    
    a2 -去进行平等的其他阵列
    
    结果
    
    true如果两个数组都是平等的
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    equals(Object[],Object[])， Objects.deepEquals(Object, Object)
  - toString
```
public static String toString(long[] a)
```
    返回指定数组的内容的字符串表示形式。的字符串表示形式由一列数组中的元素，在方括号内（ "[]"）。相邻的元素是由人物 ", "隔开（逗号后面加一个空格）。元素转换为字符串的 String.valueOf(long)。返回 "null"如果 a是 null。
    
    参数
    
    a -数组的字符串表示形式返回
    
    结果
    
    a的字符串表示形式
    
    从以下版本开始：
    
    一点五
  - toString
```
public static String toString(int[] a)
```
    返回指定数组的内容的字符串表示形式。的字符串表示形式由一列数组中的元素，在方括号内（ "[]"）。相邻的元素是由人物 ", "隔开（逗号后面加一个空格）。元素转换为字符串的 String.valueOf(int)。返回 "null"如果 a是 null。
    
    参数
    
    a -数组的字符串表示形式返回
    
    结果
    
    a的字符串表示形式
    
    从以下版本开始：
    
    一点五
  - toString
```
public static String toString(short[] a)
```
    返回指定数组的内容的字符串表示形式。的字符串表示形式由一列数组中的元素，在方括号内（ "[]"）。相邻的元素是由人物 ", "隔开（逗号后面加一个空格）。元素转换为字符串的 String.valueOf(short)。返回 "null"如果 a是 null。
    
    参数
    
    a -数组的字符串表示形式返回
    
    结果
    
    a的字符串表示形式
    
    从以下版本开始：
    
    一点五
  - toString
```
public static String toString(char[] a)
```
    返回指定数组的内容的字符串表示形式。的字符串表示形式由一列数组中的元素，在方括号内（ "[]"）。相邻的元素是由人物 ", "隔开（逗号后面加一个空格）。元素转换为字符串的 String.valueOf(char)。返回 "null"如果 a是 null。
    
    参数
    
    a -数组的字符串表示形式返回
    
    结果
    
    a的字符串表示形式
    
    从以下版本开始：
    
    一点五
  - toString
```
public static String toString(byte[] a)
```
    返回指定数组的内容的字符串表示形式。的字符串表示形式由一列数组中的元素，在方括号内（ "[]"）。相邻的元素是由人物 ", "隔开（逗号后面加一个空格）。元素转换为字符串的 String.valueOf(byte)。返回 "null"如果 a是 null。
    
    参数
    
    a -数组的字符串表示形式返回
    
    结果
    
    a的字符串表示形式
    
    从以下版本开始：
    
    一点五
  - toString
```
public static String toString(boolean[] a)
```
    返回指定数组的内容的字符串表示形式。的字符串表示形式由一列数组中的元素，在方括号内（ "[]"）。相邻的元素是由人物 ", "隔开（逗号后面加一个空格）。元素转换为字符串的 String.valueOf(boolean)。返回 "null"如果 a是 null。
    
    参数
    
    a -数组的字符串表示形式返回
    
    结果
    
    a的字符串表示形式
    
    从以下版本开始：
    
    一点五
  - toString
```
public static String toString(float[] a)
```
    返回指定数组的内容的字符串表示形式。的字符串表示形式由一列数组中的元素，在方括号内（ "[]"）。相邻的元素是由人物 ", "隔开（逗号后面加一个空格）。元素转换为字符串的 String.valueOf(float)。返回 "null"如果 a是 null。
    
    参数
    
    a -数组的字符串表示形式返回
    
    结果
    
    a的字符串表示形式
    
    从以下版本开始：
    
    一点五
  - toString
```
public static String toString(double[] a)
```
    返回指定数组的内容的字符串表示形式。的字符串表示形式由一列数组中的元素，在方括号内（ "[]"）。相邻的元素是由人物 ", "隔开（逗号后面加一个空格）。元素转换为字符串的 String.valueOf(double)。返回 "null"如果 a是 null。
    
    参数
    
    a -数组的字符串表示形式返回
    
    结果
    
    a的字符串表示形式
    
    从以下版本开始：
    
    一点五
  - toString
```
public static String toString(Object[] a)
```
    返回指定数组的内容的字符串表示形式。如果数组包含其他数组作为元素，他们是通过继承 Object的 Object.toString()方法转换为字符串，而不是它们的内容描述了他们的恒等式。
    此方法返回的值是相等的值，将返回Arrays.asList(a).toString()，除非a是null，在这种情况下，"null"返回。
    
    参数
    
    a -数组的字符串表示形式返回
    
    结果
    
    a的字符串表示形式
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    deepToString(Object[])
  - deepToString
```
public static String deepToString(Object[] a)
```
    返回指定数组的“深度内容”的字符串表示形式。如果数组包含其他数组作为元素，那么字符串表示形式包含它们的内容等。这种方法被设计用于将多维数组转换为字符串。
    的字符串表示形式由一列数组中的元素，在方括号内（"[]"）。相邻的元素是由人物", "隔开（逗号后面加一个空格）。元素转换为字符串的String.valueOf(Object)，除非他们自己阵列。
    
    如果一个元素e是原始类型的数组，它被转换成一个字符串通过调用相应的重载Arrays.toString(e)。如果一个元素e是一个引用类型的数组，它被转换成一个字符串的递归调用该方法。
    
    为了避免无限递归，如果指定的数组包含自身作为元素，或者包含本身的一个间接引用通过一个或多个级别的阵列，自我参照转换为字符串"[...]"。例如，数组只包含一个引用本身就呈现为"[[...]]"。
    
    此方法返回"null"如果指定数组null。
    
    参数
    
    a -数组的字符串表示形式返回
    
    结果
    
    a的字符串表示形式
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    toString(Object[])
  - setAll
```
public static <T> void setAll(T[] array,
                              IntFunction<? extends T> generator)
```
    设置指定数组的所有元素，使用提供的生成器函数来计算每个元素。
    如果生成器函数抛出一个异常，则将它传递给调用方，并且该数组在一个不确定的状态中离开了。
    
    参数类型
    
    T -数组元素的类型
    
    参数
    
    array数组被初始化
    
    generator -函数接受一个指数和生产这一位置的期望值
    
    异常
    
    NullPointerException -如果发电机是空的
    
    从以下版本开始：
    
    一点八
  - parallelSetAll
```
public static <T> void parallelSetAll(T[] array,
                                      IntFunction<? extends T> generator)
```
    将指定的数组的所有元素，在并行中，使用提供的生成器函数来计算每个元素。
    如果生成器函数抛出一个异常，从parallelSetAll和数组是一个不确定的状态扔是一个未检查的异常。
    
    参数类型
    
    T -数组元素的类型
    
    参数
    
    array数组被初始化
    
    generator -函数接受一个指数和生产这一位置的期望值
    
    异常
    
    NullPointerException -如果发电机是空的
    
    从以下版本开始：
    
    一点八
  - setAll
```
public static void setAll(int[] array,
                          IntUnaryOperator generator)
```
    设置指定数组的所有元素，使用提供的生成器函数来计算每个元素。
    如果生成器函数抛出一个异常，则将它传递给调用方，并且该数组在一个不确定的状态中离开了。
    
    参数
    
    array数组被初始化
    
    generator -函数接受一个指数和生产这一位置的期望值
    
    异常
    
    NullPointerException -如果发电机是空的
    
    从以下版本开始：
    
    一点八
  - parallelSetAll
```
public static void parallelSetAll(int[] array,
                                  IntUnaryOperator generator)
```
    将指定的数组的所有元素，在并行中，使用提供的生成器函数来计算每个元素。
    如果生成器函数抛出一个异常，从parallelSetAll和数组是一个不确定的状态扔是一个未检查的异常。
    
    参数
    
    array数组被初始化
    
    generator -函数接受一个指数和生产这一位置的期望值
    
    异常
    
    NullPointerException -如果发电机是空的
    
    从以下版本开始：
    
    一点八
  - setAll
```
public static void setAll(long[] array,
                          IntToLongFunction generator)
```
    设置指定数组的所有元素，使用提供的生成器函数来计算每个元素。
    如果生成器函数抛出一个异常，则将它传递给调用方，并且该数组在一个不确定的状态中离开了。
    
    参数
    
    array数组被初始化
    
    generator -函数接受一个指数和生产这一位置的期望值
    
    异常
    
    NullPointerException -如果发电机是空的
    
    从以下版本开始：
    
    一点八
  - parallelSetAll
```
public static void parallelSetAll(long[] array,
                                  IntToLongFunction generator)
```
    将指定的数组的所有元素，在并行中，使用提供的生成器函数来计算每个元素。
    如果生成器函数抛出一个异常，从parallelSetAll和数组是一个不确定的状态扔是一个未检查的异常。
    
    参数
    
    array数组被初始化
    
    generator -函数接受一个指数和生产这一位置的期望值
    
    异常
    
    NullPointerException -如果发电机是空的
    
    从以下版本开始：
    
    一点八
  - setAll
```
public static void setAll(double[] array,
                          IntToDoubleFunction generator)
```
    设置指定数组的所有元素，使用提供的生成器函数来计算每个元素。
    如果生成器函数抛出一个异常，则将它传递给调用方，并且该数组在一个不确定的状态中离开了。
    
    参数
    
    array数组被初始化
    
    generator -函数接受一个指数和生产这一位置的期望值
    
    异常
    
    NullPointerException -如果发电机是空的
    
    从以下版本开始：
    
    一点八
  - parallelSetAll
```
public static void parallelSetAll(double[] array,
                                  IntToDoubleFunction generator)
```
    将指定的数组的所有元素，在并行中，使用提供的生成器函数来计算每个元素。
    如果生成器函数抛出一个异常，从parallelSetAll和数组是一个不确定的状态扔是一个未检查的异常。
    
    参数
    
    array数组被初始化
    
    generator -函数接受一个指数和生产这一位置的期望值
    
    异常
    
    NullPointerException -如果发电机是空的
    
    从以下版本开始：
    
    一点八
  - spliterator
```
public static <T> Spliterator<T> spliterator(T[] array)
```
    返回一个 Spliterator覆盖所有指定的数组。
    报告的spliterator Spliterator.SIZED，Spliterator.SUBSIZED，Spliterator.ORDERED，和Spliterator.IMMUTABLE。
    
    参数类型
    
    T型元素
    
    参数
    
    array -数组，假设在使用过程中被修改
    
    结果
    
    一个数组中的元素spliterator
    
    从以下版本开始：
    
    一点八
  - 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指数马上过去的最后一个索引覆盖
    
    结果
    
    一个数组中的元素spliterator
    
    异常
    
    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
    
    从以下版本开始：
    
    一点八
  - 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指数马上过去的最后一个索引覆盖
    
    结果
    
    一个数组中的元素spliterator
    
    异常
    
    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
    
    从以下版本开始：
    
    一点八
  - 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指数马上过去的最后一个索引覆盖
    
    结果
    
    一个数组中的元素spliterator
    
    异常
    
    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
    
    从以下版本开始：
    
    一点八
  - 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指数马上过去的最后一个索引覆盖
    
    结果
    
    一个数组中的元素spliterator
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 startInclusive是负的， endExclusive小于 startInclusive，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    一点八
  - stream
```
public static <T> Stream<T> stream(T[] array)
```
    返回与指定的数组作为其源序列 Stream。
    
    参数类型
    
    T -数组元素的类型
    
    参数
    
    array -数组，假设在使用过程中被修改
    
    结果
    
    一种阵列 Stream
    
    从以下版本开始：
    
    一点八
  - stream
```
public static <T> Stream<T> stream(T[] array,
                                   int startInclusive,
                                   int endExclusive)
```
    返回与指定的数组作为其源指定范围内连续 Stream。
    
    参数类型
    
    T -数组元素的类型
    
    参数
    
    array -数组，假设在使用过程中被修改
    
    startInclusive -覆盖第一指标，包括
    
    endExclusive指数马上过去的最后一个索引覆盖
    
    结果
    
    一个数组的范围 Stream
    
    异常
    
    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
    
    异常
    
    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
    
    异常
    
    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
    
    异常
    
    ArrayIndexOutOfBoundsException -如果 startInclusive是负的， endExclusive小于 startInclusive，或 endExclusive大于数组大小
    
    从以下版本开始：
    
    一点八

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class Arrays

方法摘要

Methods inherited from class java.lang.Object

方法详细信息

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

sort

sort

sort

sort

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

equals

equals

equals

equals

equals

equals

equals

equals

equals

fill

fill

fill

fill

fill