Arrays (Java Platform SE 6)

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

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

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

java.util
类 Arrays

java.lang.Object
  java.util.Arrays

public class Arrays
extends Object
extends Object

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

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

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

此类是 Java Collections Framework 的成员。

从以下版本开始：: 1.2

方法摘要

static



<T> List<T>

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

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

static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
使用二分搜索法来搜索指定的 byte 型数组的范围，以获得指定的值。

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

static int binarySearch(char[] a, int fromIndex, int toIndex, char key)
使用二分搜索法来搜索指定的 char 型数组的范围，以获得指定的值。

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

static int binarySearch(double[] a, int fromIndex, int toIndex, double key)
使用二分搜索法来搜索指定的 double 型数组的范围，以获得指定的值。

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

static int binarySearch(float[] a, int fromIndex, int toIndex, float key)
使用二分搜索法来搜索指定的 float 型数组的范围，以获得指定的值。

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

static int binarySearch(int[] a, int fromIndex, int toIndex, int key)
使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。

static int binarySearch(long[] a, int fromIndex, int toIndex, long key)
使用二分搜索法来搜索指定的 long 型数组的范围，以获得指定的值。

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

static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
使用二分搜索法来搜索指定数组的范围，以获得指定对象。

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

static int binarySearch(short[] a, int fromIndex, int toIndex, short key)
使用二分搜索法来搜索指定的 short 型数组的范围，以获得指定的值。

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

static



<T> int

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

使用二分搜索法来搜索指定数组的范围，以获得指定对象。

static



<T> int

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

使用二分搜索法来搜索指定数组，以获得指定对象。

static boolean[] copyOf(boolean[] original, int newLength)
复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。

static byte[] copyOf(byte[] original, int newLength)
复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

static char[] copyOf(char[] original, int newLength)
复制指定的数组，截取或用 null 字符填充（如有必要），以使副本具有指定的长度。

static double[] copyOf(double[] original, int newLength)
复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

static float[] copyOf(float[] original, int newLength)
复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

static int[] copyOf(int[] original, int newLength)
复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

static long[] copyOf(long[] original, int newLength)
复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

static short[] copyOf(short[] original, int newLength)
复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

static



<T> T[]

copyOf(T[] original,
       int newLength)

复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。

static



<T,U> T[]

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

复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。

static boolean[] copyOfRange(boolean[] original, int from, int to)
将指定数组的指定范围复制到一个新数组。

static byte[] copyOfRange(byte[] original, int from, int to)
将指定数组的指定范围复制到一个新数组。

static char[] copyOfRange(char[] original, int from, int to)
将指定数组的指定范围复制到一个新数组。

static double[] copyOfRange(double[] original, int from, int to)
将指定数组的指定范围复制到一个新数组。

static float[] copyOfRange(float[] original, int from, int to)
将指定数组的指定范围复制到一个新数组。

static int[] copyOfRange(int[] original, int from, int to)
将指定数组的指定范围复制到一个新数组。

static long[] copyOfRange(long[] original, int from, int to)
将指定数组的指定范围复制到一个新数组。

static short[] copyOfRange(short[] original, int from, int to)
将指定数组的指定范围复制到一个新数组。

static



<T> T[]

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

将指定数组的指定范围复制到一个新数组。

static



<T,U> T[]

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

将指定数组的指定范围复制到一个新数组。

static boolean deepEquals(Object[] a1, Object[] a2)
如果两个指定数组彼此是深层相等 的，则返回 true。

static int deepHashCode(Object[] a)
基于指定数组的“深层内容”返回哈希码。

static String deepToString(Object[] a)
返回指定数组“深层内容”的字符串表示形式。

static boolean equals(boolean[] a, boolean[] a2)
如果两个指定的 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`

方法详细信息

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，则排序范围为空。）

参数：: 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 值都被认为是等效且相等的。

参数：: 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 值都被认为是等效且相等的。

参数：: 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 - 如果数组包含不可相互比较的 的元素（例如，字符串和整数）。

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 - 如果数组包含不可相互比较的 的元素（例如，字符串和整数）。

sort

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

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

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

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

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

binarySearch

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

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

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

binarySearch

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

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

参数：: a - 要搜索的数组; fromIndex - 要搜索的第一个元素的索引（包括）; toIndex - 要搜索的最后一个元素的索引（不包括）; key - 要搜索的值
返回：: 如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：: IllegalArgumentException - 如果 fromIndex > toIndex; ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
从以下版本开始：: 1.6

binarySearch

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

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

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

binarySearch

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

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

参数：: a - 要搜索的数组; fromIndex - 要搜索的第一个元素的索引（包括）; toIndex - 要搜索的最后一个元素的索引（不包括）; key - 要搜索的值
返回：: 如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：: IllegalArgumentException - 如果 fromIndex > toIndex; ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
从以下版本开始：: 1.6

binarySearch

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

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

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

binarySearch

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

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

参数：: a - 要搜索的数组; fromIndex - 要搜索的第一个元素的索引（包括）; toIndex - 要搜索的最后一个元素的索引（不包括）; key - 要搜索的值
返回：: 如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：: IllegalArgumentException - 如果 fromIndex > toIndex; ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
从以下版本开始：: 1.6

binarySearch

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

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

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

binarySearch

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

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

参数：: a - 要搜索的数组; fromIndex - 要搜索的第一个元素的索引（包括）; toIndex - 要搜索的最后一个元素的索引（不包括）; key - 要搜索的值
返回：: 如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：: IllegalArgumentException - 如果 fromIndex > toIndex; ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
从以下版本开始：: 1.6

binarySearch

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

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

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

binarySearch

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

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

参数：: a - 要搜索的数组; fromIndex - 要搜索的第一个元素的索引（包括）; toIndex - 要搜索的最后一个元素的索引（不包括）; key - 要搜索的值
返回：: 如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：: IllegalArgumentException - 如果 fromIndex > toIndex; ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
从以下版本开始：: 1.6

binarySearch

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

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

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

binarySearch

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

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

参数：: a - 要搜索的数组; fromIndex - 要搜索的第一个元素的索引（包括）; toIndex - 要搜索的最后一个元素的索引（不包括）; key - 要搜索的值
返回：: 如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：: IllegalArgumentException - 如果 fromIndex > toIndex; ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
从以下版本开始：: 1.6

binarySearch

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

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

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

binarySearch

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

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

参数：: a - 要搜索的数组; fromIndex - 要搜索的第一个元素的索引（包括）; toIndex - 要搜索的最后一个元素的索引（不包括）; key - 要搜索的值
返回：: 如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：: IllegalArgumentException - 如果 fromIndex > toIndex; ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
从以下版本开始：: 1.6

binarySearch

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

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

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

binarySearch

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

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

参数：: a - 要搜索的数组; fromIndex - 要搜索的第一个元素的索引（包括）; toIndex - 要搜索的最后一个元素的索引（不包括）; key - 要搜索的值
返回：: 如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：: ClassCastException - 如果搜索的键不能与数组的指定范围内的元素进行比较。; IllegalArgumentException - 如果 fromIndex > toIndex; ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
从以下版本开始：: 1.6

binarySearch

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

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

参数：: a - 要搜索的数组; key - 要搜索的值; c - 用来对数组进行排序的比较器。null 值指示应该使用元素的自然顺序。
返回：: 如果它包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即第一个大于此键的元素索引，如果数组中的所有元素都小于指定的键，则为 a.length。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：: ClassCastException - 如果数组包含使用指定的比较器不可相互比较 的元素，或者使用此比较器无法相互比较搜索键与数组的元素。

binarySearch

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

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

参数：: a - 要搜索的数组; fromIndex - 要搜索的第一个元素的索引（包括）; toIndex - 要搜索的最后一个元素的索引（不包括）; key - 要搜索的值; c - 用来对数组进行排序的比较器。null 值指示应该使用元素的自然顺序。
返回：: 如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：: ClassCastException - 如果范围包含使用指定的比较器不可相互比较 的元素，或者使用此比较器无法相互比较搜索键与范围中的元素。; IllegalArgumentException - 如果 fromIndex > toIndex; ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
从以下版本开始：: 1.6

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 - 要存储在数组所有元素中的值
抛出：: ArrayStoreException - 如果指定值不是可存储在指定数组中的运行时类型

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; ArrayStoreException - 如果指定值不是可存储在指定数组中的运行时类型

copyOf

public static <T> T[] copyOf(T[] original,
                             int newLength)

复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 null。当且仅当指定长度大于原数组的长度时，这些索引存在。所得数组和原数组属于完全相同的类。

参数：: original - 要复制的数组; newLength - 要返回的副本的长度
返回：: 原数组的副本，截取或用 null 填充以获得指定的长度
抛出：: NegativeArraySizeException - 如果 newLength 为负; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOf

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

复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 null。当且仅当指定长度大于原数组的长度时，这些索引存在。所得数组属于 newType 类。

参数：: original - 要复制的数组; newLength - 要返回的副本的长度; newType - 要返回的副本的类
返回：: 原数组的副本，截取或用 null 填充以获得指定的长度
抛出：: NegativeArraySizeException - 如果 newLength 为负; NullPointerException - 如果 original 为 null; ArrayStoreException - 如果从 original 中复制的元素不属于存储在 newType 类数组中的运行时类型
从以下版本开始：: 1.6

copyOf

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

复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 (byte)0。当且仅当指定长度大于原数组的长度时，这些索引存在。

参数：: original - 要复制的数组; newLength - 要返回的副本的长度
返回：: 原数组的副本，截取或用 0 填充以获得指定的长度
抛出：: NegativeArraySizeException - 如果 newLength 为负; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOf

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

复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 (short)0。当且仅当指定长度大于原数组的长度时，这些索引存在。

参数：: original - 要复制的数组; newLength - 要返回的副本的长度
返回：: 原数组的副本，截取或用 0 填充以获得指定的长度
抛出：: NegativeArraySizeException - 如果 newLength 为负; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOf

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

复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 0。当且仅当指定长度大于原数组的长度时，这些索引存在。

参数：: original - 要复制的数组; newLength - 要返回的副本的长度
返回：: 原数组的副本，截取或用 0 填充以获得指定的长度
抛出：: NegativeArraySizeException - 如果 newLength 为负; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOf

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

复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 0L。当且仅当指定长度大于原数组的长度时，这些索引存在。

参数：: original - 要复制的数组; newLength - 要返回的副本的长度
返回：: 原数组的副本，截取或用 0 填充以获得指定的长度
抛出：: NegativeArraySizeException - 如果 newLength 为负; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOf

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

复制指定的数组，截取或用 null 字符填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 '\\u000'。当且仅当指定长度大于原数组的长度时，这些索引存在。

参数：: original - 要复制的数组; newLength - 要返回的副本的长度
返回：: 原数组的副本，截取或用 null 字符填充以获得指定的长度
抛出：: NegativeArraySizeException - 如果 newLength 为负; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOf

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

复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 0f。当且仅当指定长度大于原数组的长度时，这些索引存在。

参数：: original - 要复制的数组; newLength - 要返回的副本的长度
返回：: 原数组的副本，截取或用 0 填充以获得指定的长度
抛出：: NegativeArraySizeException - 如果 newLength 为负; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOf

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

复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 0d。当且仅当指定长度大于原数组的长度时，这些索引存在。

参数：: original - 要复制的数组; newLength - 要返回的副本的长度
返回：: 原数组的副本，截取或用 0 填充以获得指定的长度
抛出：: NegativeArraySizeException - 如果 newLength 为负; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOf

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

复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 false。当且仅当指定长度大于原数组的长度时，这些索引存在。

参数：: original - 要复制的数组; newLength - 要返回的副本的长度
返回：: 原数组的副本，截取或用 false 元素填充以获得指定的长度
抛出：: NegativeArraySizeException - 如果 newLength 为负; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOfRange

public static <T> T[] copyOfRange(T[] original,
                                  int from,
                                  int to)

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

所得数组与原数组属于完全相同的类。

参数：: original - 将要从其复制一个范围的数组; from - 要复制的范围的初始索引（包括）; to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。
返回：: 包含取自原数组指定范围的新数组，截取或用 null 填充以获得所需长度
抛出：: ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length(); IllegalArgumentException - 如果 from > to; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOfRange

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

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

参数：: original - 将要从其复制一个范围的数组; from - 要复制的范围的初始索引（包括）; to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。; newType - 要返回的副本的类
返回：: 包含取自原数组指定范围的新数组，截取或用 null 填充以获得所需长度
抛出：: ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length(); IllegalArgumentException - 如果 from > to; NullPointerException - 如果 original 为 null; ArrayStoreException - 如果从 original 复制的元素不属于可以存储在 newType 类数组中的运行时类型。
从以下版本开始：: 1.6

copyOfRange

public static byte[] copyOfRange(byte[] original,
                                 int from,
                                 int to)

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

参数：: original - 将要从其复制一个范围的数组; from - 要复制的范围的初始索引（包括）; to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。
返回：: 包含取自原数组指定范围的新数组，截取或用 0 填充以获得所需长度
抛出：: ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length(); IllegalArgumentException - 如果 from > to; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOfRange

public static short[] copyOfRange(short[] original,
                                  int from,
                                  int to)

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

参数：: original - 将要从其复制一个范围的数组; from - 要复制的范围的初始索引（包括）; to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。
返回：: 包含取自原数组指定范围的新数组，截取或用 0 填充以获得所需长度
抛出：: ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length(); IllegalArgumentException - 如果 from > to; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOfRange

public static int[] copyOfRange(int[] original,
                                int from,
                                int to)

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

参数：: original - 将要从其复制一个范围的数组; from - 要复制的范围的初始索引（包括）; to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。
返回：: 包含取自原数组指定范围的新数组，截取或用 0 填充以获得所需长度
抛出：: ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length(); IllegalArgumentException - 如果 from > to; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOfRange

public static long[] copyOfRange(long[] original,
                                 int from,
                                 int to)

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

参数：: original - 将要从其复制一个范围的数组; from - 要复制的范围的初始索引（包括）; to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。
返回：: 包含取自原数组指定范围的新数组，截取或用 0 填充以获得所需长度
抛出：: ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length(); IllegalArgumentException - 如果 from > to; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOfRange

public static char[] copyOfRange(char[] original,
                                 int from,
                                 int to)

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

参数：: original - 将要从其复制一个范围的数组; from - 要复制的范围的初始索引（包括）; to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。
返回：: 包含取自原数组指定范围的新数组，截取或用 0 填充以获得所需长度
抛出：: ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length(); IllegalArgumentException - 如果 from > to; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOfRange

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

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

参数：: original - 将要从其复制一个范围的数组; from - 要复制的范围的初始索引（包括）; to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。
返回：: 包含取自原数组指定范围的新数组，截取或用 0 填充以获得所需长度
抛出：: ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length(); IllegalArgumentException - 如果 from > to; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOfRange

public static double[] copyOfRange(double[] original,
                                   int from,
                                   int to)

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

参数：: original - 将要从其复制一个范围的数组; from - 要复制的范围的初始索引（包括）; to - 要复制的范围的最后索引（不包括）。（此索引可能位于数组范围之外）。
返回：: 包含取自原数组指定范围的新数组，截取或用 0 填充以获得所需长度
抛出：: ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length(); IllegalArgumentException - 如果 from > to; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

copyOfRange

public static boolean[] copyOfRange(boolean[] original,
                                    int from,
                                    int to)

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

参数：: original - 将要从其复制一个范围的数组; from - 要复制的范围的初始索引（包括）; to - 要复制的范围的最后索引（不包括）。（此索引可能位于数组范围之外）。
返回：: 包含取自原数组指定范围的新数组，截取或用 false 元素填充以获得所需长度
抛出：: ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length(); IllegalArgumentException - 如果 from > to; NullPointerException - 如果 original 为 null
从以下版本开始：: 1.6

asList

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

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

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

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

参数：: a - 支持列表的数组。
返回：: 指定数组的列表视图。

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。与 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 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

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

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

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

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

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

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOfRange

copyOfRange

copyOfRange

copyOfRange

copyOfRange

copyOfRange

java.util
类 Arrays