Arrays (Java 2 Platform SE 5.0) - JavaTM 2 Platform Standard Edition 5.0 API 规范中文版

方法摘要

static <T> List<T> asList(T... a)
          返回一个受指定数组支持的固定大小的列表。

static int binarySearch(byte[] a, byte key)
          使用二进制搜索算法来搜索指定的 byte 型数组，以获得指定的值。

static int binarySearch(char[] a, char key)
          使用二进制搜索算法来搜索指定的 char 型数组，以获得指定的值。

static int binarySearch(double[] a, double key)
          使用二进制搜索算法来搜索指定的 double 型数组，以获得指定的值。

static int binarySearch(float[] a, float key)
          使用二进制搜索算法来搜索指定的 float 型数组，以获得指定的值。

static int binarySearch(int[] a, int key)
          使用二进制搜索算法来搜索指定的 int 型数组，以获得指定的值。

static int binarySearch(long[] a, long key)
          使用二进制搜索算法来搜索指定的 long 型数组，以获得指定的值。

static int binarySearch(Object[] a, Object key)
          使用二进制搜索算法来搜索指定数组，以获得指定对象。

static int binarySearch(short[] a, short key)
          使用二进制搜索算法来搜索指定的 short 型数组，以获得指定的值。

static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)
          使用二进制搜索算法来搜索指定数组，以获得指定对象。

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)
          如果两个指定的 boolean 型数组彼此相等，则返回 true。

static boolean equals(byte[] a, byte[] a2)
          如果两个指定的 byte 型数组彼此相等，则返回 true。

static boolean equals(char[] a, char[] a2)
          如果两个指定的 char 型数组彼此相等，则返回 true。

static boolean equals(double[] a, double[] a2)
          如果两个指定的 double 型数组彼此相等，则返回 true。

static boolean equals(float[] a, float[] a2)
          如果两个指定的 float 型数组彼此相等，则返回 true。

static boolean equals(int[] a, int[] a2)
          如果两个指定的 int 型数组彼此相等，则返回 true。

static boolean equals(long[] a, long[] a2)
          如果两个指定的 long 型数组彼此相等，则返回 true。

static boolean equals(Object[] a, Object[] a2)
          如果两个指定的 Objects 数组彼此相等，则返回 true。

static boolean equals(short[] a, short[] a2)
          如果两个指定的 short 型数组彼此相等，则返回 true。

static void fill(boolean[] a, boolean val)
          将指定的 boolean 值分配给指定 boolean 型数组的每个元素。

static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)
          将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。

static void fill(byte[] a, byte val)
          将指定的 byte 值分配给指定 byte 节型数组的每个元素。

static void fill(byte[] a, int fromIndex, int toIndex, byte val)
          将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。

static void fill(char[] a, char val)
          将指定的 char 值分配给指定 char 型数组的每个元素。

static void fill(char[] a, int fromIndex, int toIndex, char val)
          将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。

static void fill(double[] a, double val)
          将指定的 double 值分配给指定 double 型数组的每个元素。

static void fill(double[] a, int fromIndex, int toIndex, double val)
          将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。

static void fill(float[] a, float val)
          将指定的 float 值分配给指定 float 型数组的每个元素。

static void fill(float[] a, int fromIndex, int toIndex, float val)
          将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。

static void fill(int[] a, int val)
          将指定的 int 值分配给指定 int 型数组的每个元素。

static void fill(int[] a, int fromIndex, int toIndex, int val)
          将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。

static void fill(long[] a, int fromIndex, int toIndex, long val)
          将指定的 long 值分配给指定 long 型数组指定范围中的每个元素。

static void fill(long[] a, long val)
          将指定的 long 值分配给指定 long 型数组的每个元素。

static void fill(Object[] a, int fromIndex, int toIndex, Object val)
          将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。

static void fill(Object[] a, Object val)
          将指定的 Object 引用分配给指定 Object 数组的每个元素。

static void fill(short[] a, int fromIndex, int toIndex, short val)
          将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。

static void fill(short[] a, short val)
          将指定的 short 值分配给指定 short 型数组的每个元素。

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 sort(byte[] a)
          对指定的 byte 型数组按数字升序进行排序。

static void sort(byte[] a, int fromIndex, int toIndex)
          对指定 byte 型数组的指定范围按数字升序进行排序。

static void sort(char[] a)
          对指定的 char 型数组按数字升序进行排序。

static void sort(char[] a, int fromIndex, int toIndex)
          对指定 char 型数组的指定范围按数字升序进行排序。

static void sort(double[] a)
          对指定的 double 型数组按数字升序进行排序。

static void sort(double[] a, int fromIndex, int toIndex)
          对指定 double 型数组的指定范围按数字升序进行排序。

static void sort(float[] a)
          对指定的 float 型数组按数字升序进行排序。

static void sort(float[] a, int fromIndex, int toIndex)
          对指定 float 型数组的指定范围按数字升序进行排序。

static void sort(int[] a)
          对指定的 int 型数组按数字升序进行排序。

static void sort(int[] a, int fromIndex, int toIndex)
          对指定 int 型数组的指定范围按数字升序进行排序。

static void sort(long[] a)
          对指定的 long 型数组按数字升序进行排序。

static void sort(long[] a, int fromIndex, int toIndex)
          对指定 long 型数组的指定范围按数字升序进行排序。

static void sort(Object[] a)
          根据元素的自然顺序，对指定对象数组按升序进行排序。

static void sort(Object[] a, int fromIndex, int toIndex)
          根据元素的自然顺序，对指定对象数组的指定范围按升序进行排序。

static void sort(short[] a)
          对指定的 short 型数组按数字升序进行排序。

static void sort(short[] a, int fromIndex, int toIndex)
          对指定 short 型数组的指定范围按数字升序进行排序。

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 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)
          返回指定数组内容的字符串表示形式。

从类 java.lang.Object 继承的方法

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从类 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,
                        int fromIndex,
                        int toIndex)

对指定 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,
                        int fromIndex,
                        int toIndex)

对指定 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,
                        int fromIndex,
                        int toIndex)

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

参数：: 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,
                        int fromIndex,
                        int toIndex)

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

参数：: 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,
                        int fromIndex,
                        int toIndex)

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

参数：: 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,
                        int fromIndex,
                        int toIndex)

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

参数：: 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,
                        int fromIndex,
                        int toIndex)

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

参数：: 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,
                        int fromIndex,
                        int toIndex)

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

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

参数：: 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 方法而对相等的元素进行重新排序。

参数：: a - 要排序的数组。; c - 确定数组顺序的比较器。null 值指示应该使用元素的自然顺序。
抛出：: ClassCastException - 如果数组包含使用指定的比较器不可相互比较的 的元素。
另请参见：: Comparator

sort

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

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

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

参数：: a - 要排序的数组。; fromIndex - 要排序的第一个元素的索引（包括）。; toIndex - 要排序的最后一个元素的索引（不包括）。; c - 确定数组顺序的比较器。null 值指示应该使用元素的自然顺序。
抛出：: ClassCastException - 如果数组包含使用指定的比较器不可相互比较的 的元素。; IllegalArgumentException - 如果 fromIndex > toIndex; ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
另请参见：: Comparator

binarySearch

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

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

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

binarySearch

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

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

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

binarySearch

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

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

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

binarySearch

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

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

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

binarySearch

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

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

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

binarySearch

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

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

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

binarySearch

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

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

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

binarySearch

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

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

参数：: a - 要搜索的数组。; key - 要搜索的值。
返回：: 搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：: ClassCastException - 如果搜索的键不能与数组的元素进行比较。
另请参见：: Comparable, sort(Object[])

binarySearch

public static <T> int binarySearch(T[] a,
                                   T key,
                                   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,
                        long val)

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

参数：: a - 要填充的数组。; val - 要存储在数组所有元素中的值。

fill

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

将指定的 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,
                        int val)

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

参数：: a - 要填充的数组。; val - 要存储在数组所有元素中的值。

fill

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

将指定的 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,
                        short val)

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

参数：: a - 要填充的数组。; val - 要存储在数组所有元素中的值。

fill

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

将指定的 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,
                        char val)

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

参数：: a - 要填充的数组。; val - 要存储在数组所有元素中的值。

fill

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

将指定的 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,
                        byte val)

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

参数：: a - 要填充的数组。; val - 要存储在数组所有元素中的值。

fill

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

将指定的 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,
                        boolean val)

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

参数：: a - 要填充的数组。; val - 要存储在数组所有元素中的值。

fill

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

将指定的 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,
                        double val)

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

参数：: a - 要填充的数组。; val - 要存储在数组所有元素中的值。

fill

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

将指定的 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,
                        float val)

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

参数：: a - 要填充的数组。; val - 要存储在数组所有元素中的值。

fill

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

将指定的 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,
                        Object val)

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

参数：: a - 要填充的数组。; val - 要存储在数组所有元素中的值。

fill

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

将指定的 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[])

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 5.0

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

Arrays (Java 2 Platform SE 5.0) - JavaTM 2 Platform Standard Edition 5.0 API 规范中文版

java.util 类 Arrays

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

equals

equals

equals

equals

equals

equals

equals

equals

equals

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

asList

hashCode

hashCode

hashCode

hashCode

hashCode

hashCode

hashCode

hashCode

hashCode

deepHashCode

deepEquals

toString

toString

toString

toString

toString

toString

toString

toString

toString

deepToString

java.util
类 Arrays