Question

java.lang.Object
  └java.util.Arrays

---

public class Arrays

extends Object

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

除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException 。

此类中所含方法的文档都包括对实现 的简短描述。应该将这些描述视为实现注意事项，而不应将它们视为规范 的一部分。实现者应该可以随意替代其他算法，只要遵循规范本身即可。（例如， sort(Object[]) 使用的算法不必是一个合并排序算法，但它必须是稳定的。）

此类是 Java Collections Framework 的成员。

从以下版本开始：

1.2

另请参见：

Comparable , Comparator

---

方法摘要
static <T> List<T>	asList(T...a) 返回一个受指定数组支持的固定大小的列表。
staticint	binarySearch(byte[]a, bytekey) 使用二进制搜索算法来搜索指定的 byte 型数组，以获得指定的值。
staticint	binarySearch(char[]a, charkey) 使用二进制搜索算法来搜索指定的 char 型数组，以获得指定的值。
staticint	binarySearch(double[]a, doublekey) 使用二进制搜索算法来搜索指定的 double 型数组，以获得指定的值。
staticint	binarySearch(float[]a, floatkey) 使用二进制搜索算法来搜索指定的 float 型数组，以获得指定的值。
staticint	binarySearch(int[]a, intkey) 使用二进制搜索算法来搜索指定的 int 型数组，以获得指定的值。
staticint	binarySearch(long[]a, longkey) 使用二进制搜索算法来搜索指定的 long 型数组，以获得指定的值。
staticint	binarySearch(Object[]a, Objectkey) 使用二进制搜索算法来搜索指定数组，以获得指定对象。
staticint	binarySearch(short[]a, shortkey) 使用二进制搜索算法来搜索指定的 short 型数组，以获得指定的值。
static <T> int	binarySearch(T[]a, Tkey, Comparator<? super T>c) 使用二进制搜索算法来搜索指定数组，以获得指定对象。
staticboolean	deepEquals(Object[]a1, Object[]a2) 如果两个指定数组彼此是深层相等 的，则返回 true 。
staticint	deepHashCode(Object[]a) 基于指定数组的“深层内容”返回哈希码。
staticString	deepToString(Object[]a) 返回指定数组“深层内容”的字符串表示形式。
staticboolean	equals(boolean[]a, boolean[]a2) 如果两个指定的 boolean 型数组彼此相等，则返回 true 。
staticboolean	equals(byte[]a, byte[]a2) 如果两个指定的 byte 型数组彼此相等，则返回 true 。
staticboolean	equals(char[]a, char[]a2) 如果两个指定的 char 型数组彼此相等，则返回 true 。
staticboolean	equals(double[]a, double[]a2) 如果两个指定的 double 型数组彼此相等，则返回 true 。
staticboolean	equals(float[]a, float[]a2) 如果两个指定的 float 型数组彼此相等，则返回 true 。
staticboolean	equals(int[]a, int[]a2) 如果两个指定的 int 型数组彼此相等，则返回 true 。
staticboolean	equals(long[]a, long[]a2) 如果两个指定的 long 型数组彼此相等，则返回 true 。
staticboolean	equals(Object[]a, Object[]a2) 如果两个指定的 Objects 数组彼此相等，则返回 true 。
staticboolean	equals(short[]a, short[]a2) 如果两个指定的 short 型数组彼此相等，则返回 true 。
staticvoid	fill(boolean[]a, booleanval) 将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
staticvoid	fill(boolean[]a, intfromIndex, inttoIndex, booleanval) 将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。
staticvoid	fill(byte[]a, byteval) 将指定的 byte 值分配给指定 byte 节型数组的每个元素。
staticvoid	fill(byte[]a, intfromIndex, inttoIndex, byteval) 将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。
staticvoid	fill(char[]a, charval) 将指定的 char 值分配给指定 char 型数组的每个元素。
staticvoid	fill(char[]a, intfromIndex, inttoIndex, charval) 将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。
staticvoid	fill(double[]a, doubleval) 将指定的 double 值分配给指定 double 型数组的每个元素。
staticvoid	fill(double[]a, intfromIndex, inttoIndex, doubleval) 将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。
staticvoid	fill(float[]a, floatval) 将指定的 float 值分配给指定 float 型数组的每个元素。
staticvoid	fill(float[]a, intfromIndex, inttoIndex, floatval) 将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。
staticvoid	fill(int[]a, intval) 将指定的 int 值分配给指定 int 型数组的每个元素。
staticvoid	fill(int[]a, intfromIndex, inttoIndex, intval) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
staticvoid	fill(long[]a, intfromIndex, inttoIndex, longval) 将指定的 long 值分配给指定 long 型数组指定范围中的每个元素。
staticvoid	fill(long[]a, longval) 将指定的 long 值分配给指定 long 型数组的每个元素。
staticvoid	fill(Object[]a, intfromIndex, inttoIndex, Objectval) 将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
staticvoid	fill(Object[]a, Objectval) 将指定的 Object 引用分配给指定 Object 数组的每个元素。
staticvoid	fill(short[]a, intfromIndex, inttoIndex, shortval) 将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。
staticvoid	fill(short[]a, shortval) 将指定的 short 值分配给指定 short 型数组的每个元素。
staticint	hashCode(boolean[]a) 基于指定数组的内容返回哈希码。
staticint	hashCode(byte[]a) 基于指定数组的内容返回哈希码。
staticint	hashCode(char[]a) 基于指定数组的内容返回哈希码。
staticint	hashCode(double[]a) 基于指定数组的内容返回哈希码。
staticint	hashCode(float[]a) 基于指定数组的内容返回哈希码。
staticint	hashCode(int[]a) 基于指定数组的内容返回哈希码。
staticint	hashCode(long[]a) 基于指定数组的内容返回哈希码。
staticint	hashCode(Object[]a) 基于指定数组的内容返回哈希码。
staticint	hashCode(short[]a) 基于指定数组的内容返回哈希码。
staticvoid	sort(byte[]a) 对指定的 byte 型数组按数字升序进行排序。
staticvoid	sort(byte[]a, intfromIndex, inttoIndex) 对指定 byte 型数组的指定范围按数字升序进行排序。
staticvoid	sort(char[]a) 对指定的 char 型数组按数字升序进行排序。
staticvoid	sort(char[]a, intfromIndex, inttoIndex) 对指定 char 型数组的指定范围按数字升序进行排序。
staticvoid	sort(double[]a) 对指定的 double 型数组按数字升序进行排序。
staticvoid	sort(double[]a, intfromIndex, inttoIndex) 对指定 double 型数组的指定范围按数字升序进行排序。
staticvoid	sort(float[]a) 对指定的 float 型数组按数字升序进行排序。
staticvoid	sort(float[]a, intfromIndex, inttoIndex) 对指定 float 型数组的指定范围按数字升序进行排序。
staticvoid	sort(int[]a) 对指定的 int 型数组按数字升序进行排序。
staticvoid	sort(int[]a, intfromIndex, inttoIndex) 对指定 int 型数组的指定范围按数字升序进行排序。
staticvoid	sort(long[]a) 对指定的 long 型数组按数字升序进行排序。
staticvoid	sort(long[]a, intfromIndex, inttoIndex) 对指定 long 型数组的指定范围按数字升序进行排序。
staticvoid	sort(Object[]a) 根据元素的自然顺序，对指定对象数组按升序进行排序。
staticvoid	sort(Object[]a, intfromIndex, inttoIndex) 根据元素的自然顺序，对指定对象数组的指定范围按升序进行排序。
staticvoid	sort(short[]a) 对指定的 short 型数组按数字升序进行排序。
staticvoid	sort(short[]a, intfromIndex, inttoIndex) 对指定 short 型数组的指定范围按数字升序进行排序。
static <T> void	sort(T[]a, Comparator<? super T>c) 根据指定比较器产生的顺序对指定对象数组进行排序。
static <T> void	sort(T[]a, intfromIndex, inttoIndex, Comparator<? super T>c) 根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
staticString	toString(boolean[]a) 返回指定数组内容的字符串表示形式。
staticString	toString(byte[]a) 返回指定数组内容的字符串表示形式。
staticString	toString(char[]a) 返回指定数组内容的字符串表示形式。
staticString	toString(double[]a) 返回指定数组内容的字符串表示形式。
staticString	toString(float[]a) 返回指定数组内容的字符串表示形式。
staticString	toString(int[]a) 返回指定数组内容的字符串表示形式。
staticString	toString(long[]a) 返回指定数组内容的字符串表示形式。
staticString	toString(Object[]a) 返回指定数组内容的字符串表示形式。
staticString	toString(short[]a) 返回指定数组内容的字符串表示形式。

从类 java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

方法详细信息

sort

public static void sort(long[]a)

对指定的 long 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

---

sort

public static void sort(long[]a,
                        intfromIndex,
                        inttoIndex)

对指定 long 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则排序范围为空。）

该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

sort

public static void sort(int[]a)

对指定的 int 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

---

sort

public static void sort(int[]a,
                        intfromIndex,
                        inttoIndex)

对指定 int 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则排序范围为空。）

该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》 Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

sort

public static void sort(short[]a)

对指定的 short 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

---

sort

public static void sort(short[]a,
                        intfromIndex,
                        inttoIndex)

对指定 short 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则排序范围为空。）

该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

sort

public static void sort(char[]a)

对指定的 char 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

---

sort

public static void sort(char[]a,
                        intfromIndex,
                        inttoIndex)

对指定 char 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则排序范围为空。）

该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

sort

public static void sort(byte[]a)

对指定的 byte 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

---

sort

public static void sort(byte[]a,
                        intfromIndex,
                        inttoIndex)

对指定 byte 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则排序范围为空。）

该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

sort

public static void sort(double[]a)

对指定的 double 型数组按数字升序进行排序。

虽然 < 关系式对不同数字 -0.0 == 0.0 返回的结果为 true ，并且认为 NaN 值既不小于或大于任何浮点值，也不等于任何浮点值，甚至不等于它自身。但 < 关系式不能提供所有浮点值的整体排序。为了允许进行排序，此方法不使用 < 关系式来确定数字升序排序，而是利用 Double.compareTo(java.lang.Double) 来完成整体排序。此排序法不同于 < 关系式，其中 -0.0 被认为是小于 0.0 的值，并且 NaN 被认为大于其他任何浮点值。为了进行排序，所有 NaN 值都被认为是等效且相等的。

该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》 Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

---

sort

public static void sort(double[]a,
                        intfromIndex,
                        inttoIndex)

对指定 double 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则排序范围为空。）

虽然 < 关系式对不同数字 -0.0 == 0.0 返回的结果为 true ，并且认为 NaN 值既不小于或大于任何浮点值，也不等于任何浮点值，甚至不等于它自身。但 < 关系式不能提供所有浮点值的整体排序。为了允许进行排序，此方法不使用 < 关系式来确定数字升序排序，而是利用 Double.compareTo(java.lang.Double) 来完成整体排序。此排序法不同于 < 关系式，其中 -0.0 被认为是小于 0.0 的值，并且 NaN 被认为大于其他任何浮点值。为了进行排序，所有 NaN 值都被认为是等效且相等的。

该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

sort

public static void sort(float[]a)

对指定的 float 型数组按数字升序进行排序。

虽然 < 关系式对不同数字 -0.0f == 0.0f 返回的结果为 true ，并且认为 NaN 值既不小于或大于任何浮点值，也不等于任何浮点值，甚至不等于它自身。但 < 关系式不能提供所有浮点值的整体排序。为了允许进行排序，此方法不使用 < 关系式来确定数字升序排序，而是利用 Float.compareTo(java.lang.Float) 来完成整体排序。此排序法不同于 < 关系式，其中 -0.0f 被认为是小于 0.0f 的值，并且 NaN 被认为大于其他任何浮点值。为了进行排序，所有 NaN 值都被认为是等效且相等的。

该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》 Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

---

sort

public static void sort(float[]a,
                        intfromIndex,
                        inttoIndex)

对指定 float 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则排序范围为空。）

虽然 < 关系式对不同数字 -0.0f == 0.0f 返回的结果为 true ，并且认为 NaN 值既不小于或大于任何浮点值，也不等于任何浮点值，甚至不等于它自身。但 < 关系式不能提供所有浮点值的整体排序。为了允许进行排序，此方法不使用 < 关系式来确定数字升序排序，而是利用 Float.compareTo(java.lang.Float) 来完成整体排序。此排序法不同于 < 关系式，其中 -0.0f 被认为是小于 0.0f 的值，并且 NaN 被认为大于其他任何浮点值。为了进行排序，所有 NaN 值都被认为是等效且相等的。

该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

sort

public static void sort(Object[]a)

根据元素的自然顺序，对指定对象数组按升序进行排序。数组中的所有元素都必须实现 Comparable 接口。此外，数组中的所有元素都必须是可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言， e1.compareTo(e2) 不得抛出 ClassCastException ）。

保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。

该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。

参数：

a - 要排序的数组。

抛出：

ClassCastException - 如果数组包含不可相互比较的 的元素（例如，字符串和整数）。

另请参见：

Comparable

---

sort

public static void sort(Object[]a,
                        intfromIndex,
                        inttoIndex)

根据元素的自然顺序，对指定对象数组的指定范围按升序进行排序。排序的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则排序范围为空。）此范围中的所有元素都必须实现 Comparable 接口。此外，此范围中的所有元素都必须是可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言， e1.compareTo(e2) 不得抛出 ClassCastException ）。

保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。

该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。

参数：

a - 要排序的数组。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

ClassCastException - 如果数组包含不可相互比较的 的元素（例如，字符串和整数）。

另请参见：

Comparable

---

sort

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

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

保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。

该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。

参数：

a - 要排序的数组。

c - 确定数组顺序的比较器。 null 值指示应该使用元素的自然顺序。

抛出：

ClassCastException - 如果数组包含使用指定的比较器不可相互比较的 的元素。

另请参见：

Comparator

---

sort

public static <T> void sort(T[]a,
                            intfromIndex,
                            inttoIndex,
                            Comparator<? super T>c)

根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。排序的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则排序范围为空。）此范围内的所有元素都必须是通过指定比较器可相互比较的（也就是说，对于该范围中的任何 e1 和 e2 元素而言， c.compare(e1, e2) 不得抛出 ClassCastException ）。

保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。

该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。

参数：

a - 要排序的数组。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

c - 确定数组顺序的比较器。 null 值指示应该使用元素的自然顺序。

抛出：

ClassCastException - 如果数组包含使用指定的比较器不可相互比较的 的元素。

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

另请参见：

Comparator

---

binarySearch

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

使用二进制搜索算法来搜索指定的 long 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

参数：

a - 要搜索的数组。

key - 要搜索的值。

返回：

搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1) 。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，或者如果列表中的所有元素都小于指定的键，则为 list.size() 。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

另请参见：

sort(long[])

---

binarySearch

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

使用二进制搜索算法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

参数：

a - 要搜索的数组。

key - 要搜索的值。

返回：

搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1) 。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，或者如果列表中的所有元素都小于指定的键，则为 list.size() 。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

另请参见：

sort(int[])

---

binarySearch

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

使用二进制搜索算法来搜索指定的 short 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

参数：

a - 要搜索的数组。

key - 要搜索的值。

返回：

搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1) 。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，或者如果列表中的所有元素都小于指定的键，则为 list.size() 。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

另请参见：

sort(short[])

---

binarySearch

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

使用二进制搜索算法来搜索指定的 char 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

参数：

a - 要搜索的数组。

key - 要搜索的值。

返回：

搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1) 。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，或者如果列表中的所有元素都小于指定的键，则为 list.size() 。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

另请参见：

sort(char[])

---

binarySearch

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

使用二进制搜索算法来搜索指定的 byte 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

参数：

a - 要搜索的数组。

key - 要搜索的值。

返回：

搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1) 。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，或者如果列表中的所有元素都小于指定的键，则为 list.size() 。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

另请参见：

sort(byte[])

---

binarySearch

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

使用二进制搜索算法来搜索指定的 double 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。此方法认为所有 NaN 值都是等效且相等的。

参数：

a - 要搜索的数组。

key - 要搜索的值。

返回：

搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1) 。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，或者如果列表中的所有元素都小于指定的键，则为 list.size() 。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

另请参见：

sort(double[])

---

binarySearch

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

使用二进制搜索算法来搜索指定的 float 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。此方法认为所有 NaN 值都是等效且相等的。

参数：

a - 要搜索的数组。

key - 要搜索的值。

返回：

搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1) 。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，或者如果列表中的所有元素都小于指定的键，则为 list.size() 。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

另请参见：

sort(float[])

---

binarySearch

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

使用二进制搜索算法来搜索指定数组，以获得指定对象。在进行此调用之前，必须根据数组元素的自然顺序 对数组进行升序排序（通过上面的 Sort(Object[] 方法）。如果没有对数组进行排序，则结果是不明确的。（如果数组包含不可相互比较的元素（例如，字符串和整数），则无法 根据数组元素的自然顺序对数组进行排序，因此结果是不明确的。）如果数组包含多个等于指定对象的元素，则无法保证找到的是哪一个。

参数：

a - 要搜索的数组。

key - 要搜索的值。

返回：

搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1) 。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，或者如果列表中的所有元素都小于指定的键，则为 list.size() 。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

抛出：

ClassCastException - 如果搜索的键不能与数组的元素进行比较。

另请参见：

Comparable , sort(Object[])

---

binarySearch

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

使用二进制搜索算法来搜索指定数组，以获得指定对象。在进行此调用之前，必须根据指定的比较器（通过上面的 Sort(Object[]、Comparator) 方法）对数组进行升序排序。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个等于指定对象的元素，则无法保证找到的是哪一个。

参数：

a - 要搜索的数组。

key - 要搜索的值。

c - 用来对数组进行排序的比较器。 null 值指示应该使用元素的自然顺序。

返回：

搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1) 。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，或者如果列表中的所有元素都小于指定的键，则为 list.size() 。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

抛出：

ClassCastException - 如果数组包含使用指定的比较器不可相互比较 的元素，或者使用此比较器无法相互比较搜索键与数组的元素。

另请参见：

Comparable , sort(Object[], Comparator)

---

equals

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

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

参数：

a - 将测试其相等性的一个数组。

a2 - 将测试其相等性的另一个数组。

返回：

如果两个数组相等，则返回 true 。

---

equals

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

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

参数：

a - 将测试其相等性的一个数组。

a2 - 将测试其相等性的另一个数组。

返回：

如果两个数组相等，则返回 true 。

---

equals

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

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

参数：

a - 将测试其相等性的一个数组。

a2 - 将测试其相等性的另一个数组。

返回：

如果两个数组相等，则返回 true 。

---

equals

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

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

参数：

a - 将测试其相等性的一个数组。

a2 - 将测试其相等性的另一个数组。

返回：

如果两个数组相等，则返回 true 。

---

equals

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

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

参数：

a - 将测试其相等性的一个数组。

a2 - 将测试其相等性的另一个数组。

返回：

如果两个数组相等，则返回 true 。

---

equals

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

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

参数：

a - 将测试其相等性的一个数组。

a2 - 将测试其相等性的另一个数组。

返回：

如果两个数组相等，则返回 true 。

---

equals

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

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

如果以下条件成立，则认为两个 double 型数组 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)

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

如果以下条件成立，则认为两个 float 型数组 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)

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

参数：

a - 将测试其相等性的一个数组。

a2 - 将测试其相等性的另一个数组。

返回：

如果两个数组相等，则返回 true 。

---

fill

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

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

参数：

a - 要填充的数组。

val - 要存储在数组所有元素中的值。

---

fill

public static void fill(long[]a,
                        intfromIndex,
                        inttoIndex,
                        longval)

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

参数：

a - 要填充的数组。

fromIndex - 要使用指定值填充的第一个元素的索引（包括）。

toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。

val - 要存储在数组所有元素中的值。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

fill

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

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

参数：

a - 要填充的数组。

val - 要存储在数组所有元素中的值。

---

fill

public static void fill(int[]a,
                        intfromIndex,
                        inttoIndex,
                        intval)

将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。填充的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则填充范围为空。）

参数：

a - 要填充的数组。

fromIndex - 要使用指定值填充的第一个元素的索引（包括）。

toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。

val - 要存储在数组所有元素中的值。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

fill

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

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

参数：

a - 要填充的数组。

val - 要存储在数组所有元素中的值。

---

fill

public static void fill(short[]a,
                        intfromIndex,
                        inttoIndex,
                        shortval)

将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。填充的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则填充范围为空。）

参数：

a - 要填充的数组。

fromIndex - 要使用指定值填充的第一个元素的索引（包括）。

toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。

val - 要存储在数组所有元素中的值。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

fill

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

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

参数：

a - 要填充的数组。

val - 要存储在数组所有元素中的值。

---

fill

public static void fill(char[]a,
                        intfromIndex,
                        inttoIndex,
                        charval)

将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。填充的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则填充范围为空。）

参数：

a - 要填充的数组。

fromIndex - 要使用指定值填充的第一个元素的索引（包括）。

toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。

val - 要存储在数组所有元素中的值。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

fill

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

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

参数：

a - 要填充的数组。

val - 要存储在数组所有元素中的值。

---

fill

public static void fill(byte[]a,
                        intfromIndex,
                        inttoIndex,
                        byteval)

将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。填充的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则填充范围为空。）

参数：

a - 要填充的数组。

fromIndex - 要使用指定值填充的第一个元素的索引（包括）。

toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。

val - 要存储在数组所有元素中的值。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

fill

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

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

参数：

a - 要填充的数组。

val - 要存储在数组所有元素中的值。

---

fill

public static void fill(boolean[]a,
                        intfromIndex,
                        inttoIndex,
                        booleanval)

将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。填充的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则填充范围为空。）

参数：

a - 要填充的数组。

fromIndex - 要使用指定值填充的第一个元素的索引（包括）。

toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。

val - 要存储在数组所有元素中的值。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

fill

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

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

参数：

a - 要填充的数组。

val - 要存储在数组所有元素中的值。

---

fill

public static void fill(double[]a,
                        intfromIndex,
                        inttoIndex,
                        doubleval)

将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。填充的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则填充范围为空。）

参数：

a - 要填充的数组。

fromIndex - 要使用指定值填充的第一个元素的索引（包括）。

toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。

val - 要存储在数组所有元素中的值。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

fill

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

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

参数：

a - 要填充的数组。

val - 要存储在数组所有元素中的值。

---

fill

public static void fill(float[]a,
                        intfromIndex,
                        inttoIndex,
                        floatval)

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

参数：

a - 要填充的数组。

fromIndex - 要使用指定值填充的第一个元素的索引（包括）。

toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。

val - 要存储在数组所有元素中的值。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

fill

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

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

参数：

a - 要填充的数组。

val - 要存储在数组所有元素中的值。

---

fill

public static void fill(Object[]a,
                        intfromIndex,
                        inttoIndex,
                        Objectval)

将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。填充的范围从索引 fromIndex （包括）一直到索引 toIndex （不包括）。（如果 fromIndex==toIndex ，则填充范围为空。）

参数：

a - 要填充的数组。

fromIndex - 要使用指定值填充的第一个元素的索引（包括）。

toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。

val - 要存储在数组的所有元素中的值。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

---

asList

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

返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直写”到数组。）此方法同 Collection.toArray 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess 。

此方法还提供了一个创建固定长度的列表的便捷方法，该列表被初始化为包含多个元素：

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

参数：

a - 支持列表的数组。

返回：

指定数组的列表视图。

另请参见：

Collection.toArray()

---

hashCode

public static int hashCode(long[]a)

基于指定数组的内容返回哈希码。对于任何两个满足 Arrays.equals(a, b) 的 long 型数组 a 和 b ，也可以说 Arrays.hashCode(a) == Arrays.hashCode(b) 。

此方法返回的值与在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 数组元素的 Long 实例的序列。如果 a 为 null ，则此方法返回 0。

参数：

a - 要计算其哈希值的数组

返回：

a 数组基于内容的哈希码

从以下版本开始：

1.5

---

hashCode

public static int hashCode(int[]a)

基于指定数组的内容返回哈希码。对于任何两个满足 Arrays.equals(a, b) 的非 null int 型数组 a 和 b ，也可以说 Arrays.hashCode(a) == Arrays.hashCode(b) 。

此方法返回的值与在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 数组元素的 Integer 实例的序列。如果 a 为 null ，则此方法返回 0。

参数：

a - 要计算其哈希值的数组

返回：

a 数组基于内容的哈希码

从以下版本开始：

1.5

---

hashCode

public static int hashCode(short[]a)

基于指定数组的内容返回哈希码。对于任何两个满足 Arrays.equals(a, b) 的 short 型数组 a 和 b ，也可用说 Arrays.hashCode(a) == Arrays.hashCode(b) 。

此方法返回的值与在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 数组元素的 Short 实例的序列。如果 a 为 null ，则此方法返回 0。

参数：

a - 要计算其哈希值的数组

返回：

a 数组基于内容的哈希码

从以下版本开始：

1.5

---

hashCode

public static int hashCode(char[]a)

基于指定数组的内容返回哈希码。对于任何两个满足 Arrays.equals(a, b) 的 char 型数组 a 和 b ，也可用说 Arrays.hashCode(a) == Arrays.hashCode(b) 。

此方法返回的值与在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 数组元素的 Character 实例的序列。如果 a 为 null ，则此方法返回 0。

参数：

a - 要计算其哈希值的数组

返回：

a 数组基于内容的哈希码

从以下版本开始：

1.5

---

hashCode

public static int hashCode(byte[]a)

基于指定数组的内容返回哈希码。对于任何两个满足 Arrays.equals(a, b) 的 byte 型数组 a 和 b ，也可用说 Arrays.hashCode(a) == Arrays.hashCode(b) 。

此方法返回的值与在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 数组元素的 Byte 实例的序列。如果 a 为 null ，则此方法返回 0。

参数：

a - 要计算其哈希值的数组

返回：

a 数组基于内容的哈希码

从以下版本开始：

1.5

---

hashCode

public static int hashCode(boolean[]a)

基于指定数组的内容返回哈希码。对于任何两个满足 Arrays.equals(a, b) 的 boolean 型数组 a 和 b ，也可以说 Arrays.hashCode(a) == Arrays.hashCode(b) 。

此方法返回的值与在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 数组元素的 Boolean 实例的序列。如果 a 为 null ，则此方法返回 0。

参数：

a - 要计算其哈希值的数组

返回：

a 数组基于内容的哈希码

从以下版本开始：

1.5

---

hashCode

public static int hashCode(float[]a)

基于指定数组的内容返回哈希码。对于任何两个满足 Arrays.equals(a, b) 的 float 型数组 a 和 b ，也可以说 Arrays.hashCode(a) == Arrays.hashCode(b) 。

此方法返回的值与在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 数组元素的 Float 实例的序列。如果 a 为 null ，则此方法返回 0。

参数：

a - 要计算其哈希值的数组

返回：

a 数组基于内容的哈希码

从以下版本开始：

1.5

---

hashCode

public static int hashCode(double[]a)

基于指定数组的内容返回哈希码。对于任何两个满足 Arrays.equals(a, b) 的 double 型数组 a 和 b ，也可以说 Arrays.hashCode(a) == Arrays.hashCode(b) 。

此方法返回的值与在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 数组元素的 Double 实例的序列。如果 a 为 null ，则此方法返回 0。

参数：

a - 要计算其哈希值的数组

返回：

a 数组基于内容的哈希码

从以下版本开始：

1.5

---

hashCode

public static int hashCode(Object[]a)

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

对于任何两个满足 Arrays.equals(a, b) 的数组 a 和 b ，也可以说 Arrays.hashCode(a) == Arrays.hashCode(b) 。

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

参数：

a - 将计算其基于内容的哈希码的数组

返回：

a 数组基于内容的哈希码

从以下版本开始：

1.5

另请参见：

deepHashCode(Object[])

---

deepHashCode

public static int deepHashCode(Object[]a)

基于指定数组的“深层内容”返回哈希码。如果数组包含作为元素的其他数组，则哈希码将基于其内容，并以此类推，直至无穷。所以，在将自身包含为一个元素的数组上，直接或间接通过一个或多个数组级别来调用此方法是不可接受的。这种调用的行为是不明确的。

对于任何两个满足 Arrays.deepEquals(a, b) 的数组 a 和 b ，也可以说 Arrays.deepHashCode(a) == Arrays.deepHashCode(b) 。

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

参数：

a - 将计算其基于深层内容的哈希码的数组

返回：

a 数组基于深层内容的哈希码

从以下版本开始：

1.5

另请参见：

hashCode(Object[])

---

deepEquals

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

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

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

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

• e1 和 e2 都是对象引用类型的数组，并且 Arrays.deepEquals(e1, e2) 将返回 true。
• e1 和 e2 都是相同基本类型的数组，并且 Arrays.equals(e1, e2) 的适当重载将返回 true。
• e1 == e2
• e1.equals(e2) 将返回 true。

注意，此定义支持任意深度的 null 元素。

如果指定数组中的任意一个数组，直接或间接通过一个或多个数组级别，包含数组本身作为其元素，则此方法的行为是不明确的。

参数：

a1 - 将测试其相等性的一个数组

a2 - 将测试其相等性的另一个数组

返回：

如果两个数组相等，则返回 true

从以下版本开始：

1.5

另请参见：

equals(Object[],Object[])

---

toString

public static String toString(long[]a)

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

参数：

a - 返回其字符串表示形式的数组

返回：

a 的字符串表示形式

从以下版本开始：

1.5

---

toString

public static String toString(int[]a)

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

参数：

a - 返回其字符串表示形式的数组

返回：

a 的字符串表示形式

从以下版本开始：

1.5

---

toString

public static String toString(short[]a)

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

参数：

a - 返回其字符串表示形式的数组

返回：

a 的字符串表示形式

从以下版本开始：

1.5

---

toString

public static String toString(char[]a)

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

参数：

a - 返回其字符串表示形式的数组

返回：

a 的字符串表示形式

从以下版本开始：

1.5

---

toString

public static String toString(byte[]a)

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

参数：

a - 返回其字符串表示形式的数组

返回：

a 的字符串表示形式

从以下版本开始：

1.5

---

toString

public static String toString(boolean[]a)

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

参数：

a - 返回其字符串表示形式的数组

返回：

a 的字符串表示形式

从以下版本开始：

1.5

---

toString

public static String toString(float[]a)

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

参数：

a - 返回其字符串表示形式的数组

返回：

a 的字符串表示形式

从以下版本开始：

1.5

---

toString

public static String toString(double[]a)

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

参数：

a - 返回其字符串表示形式的数组

返回：

a 的字符串表示形式

从以下版本开始：

1.5

---

toString

public static String toString(Object[]a)

返回指定数组内容的字符串表示形式。如果数组包含作为元素的其他数组，则通过从 Object 中继承的 Object.toString() 方法将它们转换为字符串，这描述了它们的标识，而不是它们的内容。

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

参数：

a - 返回其字符串表示形式的数组

返回：

a 的字符串表示形式

从以下版本开始：

1.5

另请参见：

deepToString(Object[])

---

deepToString

public static String deepToString(Object[]a)

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

字符串表示形式由数组的元素列表组成，括在方括号（ "[]" ）中。相邻元素用字符 ", " （逗号加空格）分隔。这些元素通过 String.valueOf(Object) 转换为字符串，除非它们是自身的数组。

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

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

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

参数：

a - 返回其字符串表示形式的数组

返回：

a 的字符串表示形式

从以下版本开始：

1.5

另请参见：

toString(Object[])