Arrays (Java 2 Platform SE 6)

概觀

軟體套件

類別

使用

階層樹

已過時

索引

說明

Java^TM 2 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 2 Platform
Standard Ed. 6

上一個類別 下一個類別

框架 無框架

摘要：巢狀 | 欄位 | 建構子 | 方法

詳細資訊：欄位 | 建構子 | 方法

提交錯誤或意見

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