Arrays

asList

List<T> asList (T... a)

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

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

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

binarySearch

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

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

binarySearch

int binarySearch (long[] a, 
                long key)

使用二进制搜索算法搜索指定的long数组。 在发出此呼叫之前，必须对数组进行排序（如通过sort(long[])方法）。 如果没有排序，结果是不确定的。 如果数组包含具有指定值的多个元素，则不能保证会找到哪个元素。

binarySearch

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

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

binarySearch

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

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

binarySearch

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

使用二分搜索算法搜索指定长度的数组的范围。 在进行此呼叫之前，必须对范围进行排序（如通过sort(long[], int, int)方法）。 如果没有排序，结果是不确定的。 如果范围包含具有指定值的多个元素，则不能保证会找到哪个元素。

binarySearch

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

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

binarySearch

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

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

binarySearch

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

使用二分搜索算法搜索指定数组的范围。 在进行此呼叫之前，范围必须根据指定的比较器按升序排序（如sort(T[], int, int, Comparator)方法）。 如果没有排序，结果是不确定的。 如果范围包含与指定对象相同的多个元素，则不能保证会找到哪一个元素。

binarySearch

int binarySearch (byte[] a, 
                byte key)

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

binarySearch

int binarySearch (short[] a, 
                short key)

使用二进制搜索算法搜索指定的短裤阵列以获得指定的值。 在进行此调用之前，必须对数组进行排序（如通过sort(short[])方法）。 如果没有排序，结果是不确定的。 如果数组包含具有指定值的多个元素，则不能保证会找到哪个元素。

binarySearch

int binarySearch (Object[] a, 
                Object key)

使用二分搜索算法在指定的数组中搜索指定的对象。 在进行此调用之前，必须按照元素的natural ordering升序排列数组（如sort(Object[])方法）。 如果没有排序，结果是不确定的。 （如果数组包含不可相互比较的元素（例如，字符串和整数），则不能根据元素的自然顺序进行排序，因此结果未定义。）如果数组包含与指定对象相同的多个元素，不能保证哪一个会被发现。

binarySearch

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

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

binarySearch

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

使用二分搜索算法搜索指定数组的范围。 的范围必须根据被按升序排列natural ordering元素（如由sort(Object[], int, int)方法）之前使该呼叫。 如果没有排序，结果是不确定的。 （如果范围包含不可相互比较的元素（例如，字符串和整数），则不能根据其元素的自然顺序进行排序，因此结果是未定义的。）如果范围包含多个元素等于指定对象，不能保证哪一个会被发现。

binarySearch

int binarySearch (char[] a, 
                char key)

使用二分搜索算法搜索指定的字符数组以获得指定的值。 在进行此调用之前，必须对数组进行排序（如sort(char[])方法）。 如果没有排序，结果是不确定的。 如果数组包含具有指定值的多个元素，则不能保证会找到哪个元素。

binarySearch

int binarySearch (int[] a, 
                int key)

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

binarySearch

int binarySearch (double[] a, 
                double key)

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

binarySearch

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

使用二分搜索算法在指定的数组中搜索指定的对象。 在进行此调用之前，必须根据指定的比较器按照升序排列数组（如sort(T[], Comparator)方法）。 如果没有排序，结果是不确定的。 如果数组包含与指定对象相同的多个元素，则不能保证会找到哪一个元素。

binarySearch

int binarySearch (float[] a, 
                float key)

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

copyOf

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

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

copyOf

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

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

copyOf

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

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

copyOf

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

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

copyOf

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

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

copyOf

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

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

copyOf

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

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

copyOf

T[] copyOf (T[] original, 
                int newLength)

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

copyOf

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

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

copyOf

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

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

copyOfRange

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 。

copyOfRange

T[] copyOfRange (T[] original, 
                int from, 
                int to)

将指定数组的指定范围复制到新数组中。 范围的初始索引（ from ）必须介于0和original.length之间，包括0和original.length 。 original[from]处的值被放置到副本的初始元素中（除非from == original.length或from == to ）。 原始数组中后续元素的值将放入副本中的后续元素中。 范围的最终索引（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， null将放置在索引大于或等于original.length - from的副本的所有元素中。 返回数组的长度将为to - from 。

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

copyOfRange

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 。

copyOfRange

float[] copyOfRange (float[] original, 
                int from, 
                int to)

将指定数组的指定范围复制到新数组中。 范围的初始索引（ from ）必须介于0和original.length之间，包括0和original.length 。 将original[from]处的值放入副本的初始元素中（除非from == original.length或from == to ）。 原始数组中后续元素的值将放入副本中的后续元素中。 范围的最终索引（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， 0f将放置在索引大于或等于original.length - from的副本的所有元素中。 返回数组的长度将为to - from 。

copyOfRange

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 。

copyOfRange

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 。

copyOfRange

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 。

copyOfRange

T[] copyOfRange (U[] original, 
                int from, 
                int to, 
                Class<? extends T[]> newType)

将指定数组的指定范围复制到新数组中。 范围的初始索引（ from ）必须介于零和original.length之间（包括）。 将original[from]处的值放入副本的初始元素中（除非from == original.length或from == to ）。 原始数组中后续元素的值将放入副本中的后续元素中。 范围的最终索引（ to ）必须大于或等于from ，可能大于original.length ，在这种情况下， null将放置在索引大于或等于original.length - from的副本的所有元素中。 返回数组的长度将为to - from 。 结果数组是类newType 。

copyOfRange

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 。

copyOfRange

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 。

deepEquals

boolean deepEquals (Object[] a1, 
                Object[] a2)

如果两个指定的数组彼此深度相等 ，则返回true 。 与equals(Object[], Object[])方法不同，此方法适用于任意深度的嵌套数组。

如果二者都是 null ，或者如果它们引用包含相同数量的元素的数组，并且两个数组中的所有相应元素对都非常相等，则两个数组引用被认为是相等的。

如果满足以下任何条件，则两个可能的 null元素 e1和 e2是深深相等的：

• e1 and e2 are both arrays of object reference types, and Arrays.deepEquals(e1, e2) would return true
• e1 and e2 are arrays of the same primitive type, and the appropriate overloading of Arrays.equals(e1, e2) would return true.
• e1 == e2
• e1.equals(e2) would return true.

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

deepHashCode

int deepHashCode (Object[] a)

根据指定数组的“深层内容”返回哈希码。 如果数组包含其他数组作为元素，则散列码基于其内容等，并且无限。 因此，在包含自身作为元素的数组上调用此方法是不可接受的，无论是直接还是间接通过一个或多个数组级别。 这种调用的行为是未定义的。

对于任何两个阵列 a和 b这样的 Arrays.deepEquals(a, b) ，情况也是如此 Arrays.deepHashCode(a) == Arrays.deepHashCode(b) 。

通过此方法返回的值的计算是类似于由返回的值的hashCode()包含相同的元素作为a以相同的顺序在列表上，有一点不同：如果一个元素的a e本身是一个阵列，其散列代码不是通过调用e.hashCode()来计算的，而是通过调用适当的Arrays.hashCode(e)的重载，如果e是一个基本类型的数组，或者如果e是一个引用类型的数组，则递归调用Arrays.deepHashCode(e) 。 如果a是null ，则此方法返回0。

deepToString

String deepToString (Object[] a)

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

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

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

为避免无限递归，如果指定数组包含自身作为元素，或者包含通过一个或多个级别的数组对其自身的间接引用，则自引用将转换为字符串"[...]" 。 例如，只包含对自身引用的数组将被渲染为"[[...]]" 。

如果指定数组是 null此方法返回 "null"。

equals

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

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

equals

boolean equals (double[] a, 
                double[] a2)

如果两个指定的双精度数组相等 ，则返回true 。 如果两个数组包含相同数量的元素，则两个数组被视为相等，并且两个数组中的所有对应元素对都相等。 换句话说，如果两个数组按照相同的顺序包含相同的元素，则它们是相等的。 另外，如果两个数组都是null，则认为两个数组引用相等。

如果 满足以下 条件 ，两个双打 d1和 d2被认为是相等的：

    new Double(d1).equals(new Double(d2))

equals

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

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

equals

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

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

equals

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

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

equals

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

如果两个指定的整数数组相等 ，则返回true 。 如果两个数组包含相同数量的元素，则两个数组被视为相等，并且两个数组中的所有对应元素对都相等。 换句话说，如果两个数组按照相同的顺序包含相同的元素，则它们是相等的。 另外，如果两个数组都是null ，则两个数组引用被视为相等。

equals

boolean equals (float[] a, 
                float[] a2)

如果两个指定的浮点数组相等 ，则返回true 。 如果两个数组包含相同数量的元素，则两个数组被视为相等，并且两个数组中的所有对应元素对都相等。 换句话说，如果两个数组按照相同的顺序包含相同的元素，则它们是相等的。 另外，如果两个数组都是null ，则两个数组引用被视为相等。

如果满足以下 条件，则两个浮点数 f1和 f2被视为相等：

    new Float(f1).equals(new Float(f2))

equals

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

如果两个指定的短裤阵列彼此相等 ，则返回true 。 如果两个数组包含相同数量的元素，则两个数组被视为相等，并且两个数组中的所有对应元素对都相等。 换句话说，如果两个数组按照相同的顺序包含相同的元素，则它们是相等的。 此外，如果两个数组都是null ，则两个数组引用被视为相等。

equals

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

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

fill

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

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

fill

void fill (float[] a, 
                float val)

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

fill

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

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

fill

void fill (char[] a, 
                char val)

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

fill

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

将指定的布尔值指定给指定的布尔数组的指定范围的每个元素。 要填充的范围从索引fromIndex （含）扩展到索引toIndex （不包括）。 （如果fromIndex==toIndex ，要填充的范围是空的。）

fill

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

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

fill

void fill (Object[] a, 
                Object val)

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

fill

void fill (double[] a, 
                double val)

将指定的double值指定给指定的双精度数组的每个元素。

fill

void fill (long[] a, 
                long val)

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

fill

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

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

fill

void fill (byte[] a, 
                byte val)

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

fill

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

将指定的int值指定给指定的整数数组的指定范围的每个元素。 要填充的范围从索引fromIndex （含）扩展到索引toIndex （仅限于）。 （如果fromIndex==toIndex ， 则要填写的范围为空。）

fill

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

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

fill

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

将指定的short值指定给指定短裤数组的指定范围的每个元素。 要填充的范围从索引fromIndex （含）扩展到索引toIndex （仅限于）。 （如果fromIndex==toIndex ，要填充的范围是空的。）

fill

void fill (boolean[] a, 
                boolean val)

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

fill

void fill (short[] a, 
                short val)

将指定的short值分配给指定短裤阵列的每个元素。

fill

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

将指定的对象引用分配给指定的对象数组的指定范围的每个元素。 要填充的范围从索引fromIndex （含）扩展到索引toIndex （仅限于）。 （如果fromIndex==toIndex ， 则要填充的范围为空。）

fill

void fill (int[] a, 
                int val)

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

hashCode

int hashCode (byte[] a)

根据指定数组的内容返回散列码。 对于任何两个byte阵列a和b这样的Arrays.equals(a, b) ，情况也是如此Arrays.hashCode(a) == Arrays.hashCode(b) 。

此方法返回的值与在hashCode上调用hashCode方法所获得的值相同， List包含Byte实例序列， Byte实例代表a中的元素按相同顺序排列。 如果a是null ，则此方法返回0。

hashCode

int hashCode (boolean[] a)

根据指定数组的内容返回散列码。 对于任何两个boolean阵列a和b这样的Arrays.equals(a, b) ，这也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。

此方法返回的值与通过调用hashCode上的hashCode方法所获得的值相同， List包含Boolean实例序列， Boolean实例代表a中的元素按相同顺序排列。 如果a是null ，则此方法返回0。

hashCode

int hashCode (char[] a)

根据指定数组的内容返回散列码。 对于任何两个char a阵列和b使得Arrays.equals(a, b)，它也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。

此方法返回的值与在hashCode上调用hashCode方法所获得的值相同， List包含Character实例序列， Character实例代表a中的元素按相同顺序排列。 如果a是null ，则此方法返回0。

hashCode

int hashCode (long[] a)

根据指定数组的内容返回散列码。 对于任何两个long阵列a和b这样的Arrays.equals(a, b) ，这也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。

通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Long实例表示的a以相同顺序的元素。 如果a是null ，则此方法返回0。

hashCode

int hashCode (int[] a)

根据指定数组的内容返回散列码。 对于任何两个非空int的数组a和b这样的Arrays.equals(a, b) ，这也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。

此方法返回的值与通过在hashCode上调用hashCode方法所获得的值相同， List包含Integer实例序列， Integer实例代表a中的元素按相同顺序排列。 如果a是null ，则此方法返回0。

hashCode

int hashCode (float[] a)

根据指定数组的内容返回散列码。 对于任何两个float阵列a和b这样的Arrays.equals(a, b) ，这也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。

此方法返回的值与在hashCode上调用hashCode方法所获得的值相同， List包含Float实例序列， Float实例代表a中的元素按相同顺序排列。 如果a是null ，则此方法返回0。

hashCode

int hashCode (short[] a)

根据指定数组的内容返回散列码。 对于任何两个short a阵列和b使得Arrays.equals(a, b)，它也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。

此方法返回的值与在hashCode上调用hashCode方法所获得的值相同， List包含Short实例序列， Short实例代表a中的元素按相同顺序排列。 如果a是null ，则此方法返回0。

hashCode

int hashCode (Object[] a)

根据指定数组的内容返回散列码。 如果数组包含其他数组作为元素，则哈希码基于其身份而不是其内容。 因此，可以接受在包含自身作为元素的数组上调用此方法，可以直接或间接通过一个或多个数组级别进行调用。

对于任何两个数组 a和 b这样的 Arrays.equals(a, b) ，它也是 Arrays.hashCode(a) == Arrays.hashCode(b)的情况。

此方法返回的值等于 Arrays.asList(a).hashCode()将返回的 值 ，除非 a是 null ，在这种情况下返回 0 。

hashCode

int hashCode (double[] a)

根据指定数组的内容返回散列码。 对于任何两个double阵列a和b这样的Arrays.equals(a, b) ，这也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。

此方法返回的值与通过在hashCode上调用hashCode方法所获得的值相同， List包含Double实例序列， Double实例代表a中的元素按相同顺序排列。 如果a是null ，则此方法返回0。

parallelPrefix

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

针对数组的给定子范围执行 parallelPrefix(Object[], BinaryOperator) 。

parallelPrefix

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

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

parallelPrefix

void parallelPrefix (long[] array, 
                LongBinaryOperator op)

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

parallelPrefix

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

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

parallelPrefix

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

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

parallelPrefix

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

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

parallelPrefix

void parallelPrefix (double[] array, 
                DoubleBinaryOperator op)

使用提供的函数并行累积给定数组中的每个元素。 例如，如果数组最初包含[2.0, 1.0, 0.0, 3.0]并且该操作执行加法，则返回时数组将包含[2.0, 3.0, 3.0, 6.0] 。 并行前缀计算通常比大型数组的顺序循环更有效。

由于浮点运算可能不是严格关联的，因此返回的结果可能与顺序执行操作时得到的值不同。

parallelPrefix

void parallelPrefix (int[] array, 
                IntBinaryOperator op)

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

parallelSetAll

void parallelSetAll (double[] array, 
                IntToDoubleFunction generator)

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

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

parallelSetAll

void parallelSetAll (int[] array, 
                IntUnaryOperator generator)

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

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

parallelSetAll

void parallelSetAll (long[] array, 
                IntToLongFunction generator)

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

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

parallelSetAll

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

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

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

parallelSort

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

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

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

parallelSort

void parallelSort (long[] a)

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

parallelSort

void parallelSort (short[] a)

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

parallelSort

void parallelSort (double[] a)

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

所述<关系不能在所有的双精度值提供一个总次序： -0.0d == 0.0d是true和Double.NaN值进行比较既不小于，大于，也不等于任何值，甚至本身。 此方法使用由该方法所施加的总订单compareTo(T) ： -0.0d被视为小于值0.0d和Double.NaN比任何其他值考虑更大，并且所有Double.NaN值被认为是相等的。

parallelSort

void parallelSort (char[] a)

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

parallelSort

void parallelSort (double[] a, 
                int fromIndex, 
                int toIndex)

将数组的指定范围按升序编号排序。 要排序的范围从索引fromIndex （含）扩展到索引toIndex （排除）。 如果fromIndex == toIndex ，要排序的范围是空的。

所述<关系不能在所有的双精度值提供一个总次序： -0.0d == 0.0d是true和Double.NaN值进行比较既不小于，大于，也不等于任何值，甚至本身。 此方法使用方法compareTo(T)施加的总顺序： -0.0d被视为小于值0.0d并且Double.NaN被视为大于任何其他值，并且所有Double.NaN值都被视为相等。

parallelSort

void parallelSort (T[] a)

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

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

parallelSort

void parallelSort (float[] a)

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

<关系不提供所有浮点值的全部订单： -0.0f == 0.0f是true并且Float.NaN值与既不是Float.NaN值也不小于，大于或等于任何值都相比较。 此方法使用方法compareTo(T)施加的总顺序： -0.0f被视为小于值0.0f并且Float.NaN被视为大于任何其他值，并且所有Float.NaN值都被视为相等。

parallelSort

void parallelSort (byte[] a)

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

parallelSort

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

将数组的指定范围按升序编号排序。 要排序的范围从索引fromIndex （含）扩展到索引toIndex （排除）。 如果fromIndex == toIndex ，要排序的范围是空的。

parallelSort

void parallelSort (int[] a)

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

parallelSort

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

将数组的指定范围按升序编号排序。 要排序的范围从索引fromIndex （含）延伸至索引toIndex （排除）。 如果fromIndex == toIndex ，要排序的范围为空。

parallelSort

void parallelSort (float[] a, 
                int fromIndex, 
                int toIndex)

将数组的指定范围按升序编号排序。 要排序的范围从索引fromIndex （含）扩展到索引toIndex （排除）。 如果fromIndex == toIndex ，要排序的范围是空的。

<关系不会为所有浮点值提供全部订单： -0.0f == 0.0f是true而Float.NaN值与任何值（即使其本身）的比较都不小于，大于或等于任何值。 该方法使用方法compareTo(T)施加的总顺序： -0.0f被视为小于值0.0f并且Float.NaN被认为大于任何其他值，并且所有Float.NaN值被认为是相等的。

parallelSort

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

将数组的指定范围按升序编号排序。 要排序的范围从索引fromIndex （含）扩展到索引toIndex （排他）。 如果fromIndex == toIndex ，要排序的范围是空的。

parallelSort

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

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

parallelSort

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

将数组的指定范围按升序编号排序。 要排序的范围从索引fromIndex （含）扩展到索引toIndex （排除）。 如果fromIndex == toIndex ，要排序的范围为空。

parallelSort

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

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

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

parallelSort

void parallelSort (T[] a, 
                int fromIndex, 
                int toIndex, 
                Comparator<? super T> cmp)

根据指定比较器引发的顺序对指定的对象数组的指定范围进行排序。 要排序的范围从索引fromIndex （含）延伸到索引toIndex （排除）。 （如果fromIndex==toIndex ，则排序范围为空。）范围内的所有元素都必须是指定比较相互比较的 （即， c.compare(e1, e2)不得抛出ClassCastException任何元件e1和e2在范围内）。

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

setAll

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

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

如果生成器函数抛出一个异常，它会中继给调用者，并且数组处于不确定状态。

setAll

void setAll (double[] array, 
                IntToDoubleFunction generator)

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

如果生成器函数抛出一个异常，它会中继给调用者，并且数组处于不确定状态。

setAll

void setAll (long[] array, 
                IntToLongFunction generator)

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

如果生成器函数抛出一个异常，它会中继给调用者，并且数组处于不确定状态。

setAll

void setAll (int[] array, 
                IntUnaryOperator generator)

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

如果生成器函数抛出一个异常，它会中继给调用者，并且数组处于不确定状态。

sort

void sort (T[] a, 
                int fromIndex, 
                int toIndex, 
                Comparator<? super T> c)

根据指定比较器引发的顺序对指定的对象数组的指定范围进行排序。 要排序的范围从索引fromIndex （含）扩展到索引toIndex （排除）。 （如果fromIndex==toIndex ，则排序范围为空。）范围内的所有元素都必须是指定比较相互比较的 （即， c.compare(e1, e2)不得抛出ClassCastException任何元件e1和e2在范围内）。

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

实现注意事项：这个实现是一个稳定的自适应迭代mergesort，当输入数组部分排序时，需要远远少于n lg（n）的比较，同时在输入数组是随机排序时提供传统mergesort的性能。 如果输入数组几乎排序，则实现需要大约n次比较。 临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用。

该实现在输入数组中具有升序和降序的相等优势，并且可以利用相同输入数组的不同部分中的升序和降序。 它非常适合合并两个或多个有序数组：简单地连接数组并对结果数组进行排序。

这个实现是根据Tim Peters的Python列表排序进行的（ TimSort ）。 它使用Peter McIlroy的“Optimistic Sorting and Information Theoretic Complexity”中的技术，在Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms，第467-474页，1993年1月。

sort

void sort (int[] a)

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

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (long[] a, 
                int fromIndex, 
                int toIndex)

将数组的指定范围按升序排序。 要排序的范围从索引fromIndex （含）扩展到索引toIndex （排他）。 如果fromIndex == toIndex ，要排序的范围是空的。

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (double[] a)

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

<关系不会提供所有双-0.0d == 0.0d值的全部命令： -0.0d == 0.0d是true并且Double.NaN值与任何值（即使它本身）的比较都不小于，大于或等于任何值。 该方法使用由方法compareTo(T)施加的总顺序： -0.0d被视为小于值0.0d并且Double.NaN被认为大于任何其他值并且所有Double.NaN值被认为是相等的。

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (short[] a)

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

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (char[] a, 
                int fromIndex, 
                int toIndex)

将数组的指定范围按升序排序。 要排序的范围从索引fromIndex （含）扩展到索引toIndex （排除）。 如果fromIndex == toIndex ，要排序的范围是空的。

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (long[] a)

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

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (float[] a, 
                int fromIndex, 
                int toIndex)

将数组的指定范围按升序排序。 要排序的范围从索引fromIndex （含）扩展到索引toIndex （不包括）。 如果fromIndex == toIndex ，要排序的范围为空。

<关系不会提供所有浮点值的全部订单： -0.0f == 0.0f是true并且Float.NaN值与任何值（即使其自身）的比较都不小于，大于或等于任何值。 此方法使用方法compareTo(T)施加的总顺序： -0.0f被视为小于值0.0f而Float.NaN被视为大于任何其他值，并且所有Float.NaN值都被视为相等。

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (short[] a, 
                int fromIndex, 
                int toIndex)

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

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (T[] a, 
                Comparator<? super T> c)

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

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

实现注意事项：这个实现是一个稳定的自适应迭代mergesort，当输入数组部分排序时，需要远远少于n lg（n）的比较，同时在输入数组是随机排序时提供传统mergesort的性能。 如果输入数组几乎排序，则实现需要大约n次比较。 临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用。

该实现在输入数组中具有升序和降序的相等优势，并且可以利用相同输入数组的不同部分中的升序和降序。 它非常适合合并两个或多个有序数组：简单地连接数组并对结果数组进行排序。

这个实现是根据Tim Peters的Python列表排序（ TimSort ）改编的。 它使用Peter McIlroy的“Optimistic Sorting and Information Theoretic Complexity”中的技术，在Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms，第467-474页，1993年1月。

sort

void sort (byte[] a)

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

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (Object[] a, 
                int fromIndex, 
                int toIndex)

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

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

实现注意事项：这个实现是一个稳定的自适应迭代mergesort，当输入数组部分排序时，需要远远少于n lg（n）的比较，同时在输入数组是随机排序时提供传统mergesort的性能。 如果输入数组几乎排序，则实现需要大约n次比较。 临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用。

该实现在输入数组中具有升序和降序的相等优势，并且可以利用相同输入数组的不同部分中的升序和降序。 它非常适合合并两个或多个有序数组：简单地连接数组并对结果数组进行排序。

这个实现是根据Tim Peters的Python列表排序进行的（ TimSort ）。 它使用Peter McIlroy的“Optimistic Sorting and Information Theoretic Complexity”中的技术，在Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms，第467-474页，1993年1月。

sort

void sort (char[] a)

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

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (double[] a, 
                int fromIndex, 
                int toIndex)

将数组的指定范围按升序排序。 要排序的范围从索引fromIndex （含）扩展到索引toIndex （排除）。 如果fromIndex == toIndex ，要排序的范围是空的。

<关系不会在所有双-0.0d == 0.0d值上提供全部的顺序： -0.0d == 0.0d是true并且Double.NaN值与既不是Double.NaN值也不小于，大于或等于任何值都是相同的。 该方法使用由方法compareTo(T)施加的总顺序： -0.0d被视为小于值0.0d并且Double.NaN被认为大于任何其他值并且所有Double.NaN值被视为相等。

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (Object[] a)

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

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

实现注意事项：这个实现是一个稳定的自适应迭代mergesort，当输入数组部分排序时，需要远远少于n lg（n）的比较，同时在输入数组是随机排序时提供传统mergesort的性能。 如果输入数组几乎排序，则实现需要大约n次比较。 临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用。

该实现在输入数组中具有升序和降序的相等优势，并且可以利用相同输入数组的不同部分中的升序和降序。 它非常适合合并两个或多个有序数组：简单地连接数组并对结果数组进行排序。

这个实现是根据Tim Peters的Python列表排序（ TimSort ）改编的。 它使用Peter McIlroy的“Optimistic Sorting and Information Theoretic Complexity”中的技术，在Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms，第467-474页，1993年1月。

sort

void sort (int[] a, 
                int fromIndex, 
                int toIndex)

将数组的指定范围按升序排序。 要排序的范围从索引fromIndex （含）延伸至索引toIndex （排除）。 如果fromIndex == toIndex ，要排序的范围是空的。

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (byte[] a, 
                int fromIndex, 
                int toIndex)

将数组的指定范围按升序排序。 要排序的范围从索引fromIndex （含）扩展到索引toIndex （排除）。 如果fromIndex == toIndex ，要排序的范围是空的。

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

sort

void sort (float[] a)

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

<关系不会提供所有浮点值的全部订单： -0.0f == 0.0f是true并且Float.NaN值与任何值（即使其自身）的比较都不小于，大于或等于任何值。 此方法使用方法compareTo(T)施加的总顺序： -0.0f被视为小于值0.0f并且Float.NaN被视为大于任何其他值，并且所有Float.NaN值被视为相等。

实现注释：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort。 该算法在许多数据集上提供O（n log（n））性能，这些数据集导致其他快速排序降级为二次性能，并且通常比传统的（单枢纽）Quicksort实现更快。

spliterator

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

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

该报告spliterator SIZED ， SUBSIZED ， ORDERED ，并 IMMUTABLE 。