©
This document uses PHP Chinese website manual Release
|
JavaTM 2 Platform Standard Ed. 6 |
|||||||||
上一个类 下一个类 | 框架 无框架 | |||||||||
摘要: 嵌套 | 字段 | 构造方法 | 方法 | 详细信息: 字段 | 构造方法 | 方法 |
java.lang.Object java.util.Arrays
public class Arrays
此类包含用来操作数组(比如排序和搜索)的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
除非特别注明,否则如果指定数组引用为 null,则此类中的方法都会抛出 NullPointerException。
此类中所含方法的文档都包括对实现 的简短描述。应该将这些描述视为实现注意事项,而不应将它们视为规范 的一部分。实现者应该可以随意替代其他算法,只要遵循规范本身即可。(例如,sort(Object[]) 使用的算法不必是一个合并排序算法,但它必须是稳定的。)
此类是 Java Collections Framework 的成员。
方法摘要 | ||
---|---|---|
static
|
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
|
binarySearch(T[] a,
int fromIndex,
int toIndex,
T key,
Comparator<? super T> c)
使用二分搜索法来搜索指定数组的范围,以获得指定对象。 |
|
static
|
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
|
copyOf(T[] original,
int newLength)
复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。 |
|
static
|
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
|
copyOfRange(T[] original,
int from,
int to)
将指定数组的指定范围复制到一个新数组。 |
|
static
|
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
|
sort(T[] a,
Comparator<? super T> c)
根据指定比较器产生的顺序对指定对象数组进行排序。 |
|
static
|
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 |
方法详细信息 |
---|
public static void sort(long[] a)
a
- 要排序的数组public static void sort(long[] a, int fromIndex, int 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
public static void sort(int[] a)
a
- 要排序的数组public static void sort(int[] a, int fromIndex, int 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
public static void sort(short[] a)
a
- 要排序的数组public static void sort(short[] a, int fromIndex, int 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
public static void sort(char[] a)
a
- 要排序的数组public static void sort(char[] a, int fromIndex, int 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
public static void sort(byte[] a)
a
- 要排序的数组public static void sort(byte[] a, int fromIndex, int 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
public static void sort(double[] a)
虽然 <
关系式对不同数字 -0.0 == 0.0
返回的结果为 true
,并且认为 NaN 值既不小于或大于任何浮点值,也不等于任何浮点值,甚至不等于它自身。但 <
关系式不能提供所有浮点值的整体排序。为了允许进行排序,此方法不使用 <
关系式来确定数字升序排序,而是利用 Double.compareTo(java.lang.Double)
来完成整体排序。此排序法不同于 <
关系式,其中 -0.0
被认为是小于 0.0
的值,并且 NaN 被认为大于其他任何浮点值。为了进行排序,所有 NaN 值都被认为是等效且相等的。
该排序算法是一个经过调优的快速排序法,改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能,这导致其他快速排序会降低二次型性能。
a
- 要排序的数组public static void sort(double[] a, int fromIndex, int toIndex)
虽然 <
关系式对不同数字 -0.0 == 0.0
返回的结果为 true
,并且认为 NaN 值既不小于或大于任何浮点值,也不等于任何浮点值,甚至不等于它自身。但 <
关系式不能提供所有浮点值的整体排序。为了允许进行排序,此方法不使用 <
关系式来确定数字升序排序,而是利用 Double.compareTo(java.lang.Double)
来完成整体排序。此排序法不同于 <
关系式,其中 -0.0
被认为是小于 0.0
的值,并且 NaN 被认为大于其他任何浮点值。为了进行排序,所有 NaN 值都被认为是等效且相等的。
该排序算法是一个经过调优的快速排序法,改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能,这导致其他快速排序会降低二次型性能。
a
- 要排序的数组fromIndex
- 要排序的第一个元素的索引(包括)toIndex
- 要排序的最后一个元素的索引(不包括)
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static void sort(float[] a)
虽然 <
关系式对不同数字 -0.0f == 0.0f
返回的结果为 true
,并且认为 NaN 值既不小于或大于任何浮点值,也不等于任何浮点值,甚至不等于它自身。但 <
关系式不能提供所有浮点值的整体排序。为了允许进行排序,此方法不使用 <
关系式来确定数字升序排序,而是利用 Float.compareTo(java.lang.Float)
来完成整体排序。此排序法不同于 <
关系式,其中 -0.0f
被认为是小于 0.0f
的值,并且 NaN 被认为大于其他任何浮点值。为了进行排序,所有 NaN 值都被认为是等效且相等的。
该排序算法是一个经过调优的快速排序法,改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能,这导致其他快速排序会降低二次型性能。
a
- 要排序的数组public static void sort(float[] a, int fromIndex, int toIndex)
虽然 <
关系式对不同数字 -0.0f == 0.0f
返回的结果为 true
,并且认为 NaN 值既不小于或大于任何浮点值,也不等于任何浮点值,甚至不等于它自身。但 <
关系式不能提供所有浮点值的整体排序。为了允许进行排序,此方法不使用 <
关系式来确定数字升序排序,而是利用 Float.compareTo(java.lang.Float)
来完成整体排序。此排序法不同于 <
关系式,其中 -0.0f
被认为是小于 0.0f
的值,并且 NaN 被认为大于其他任何浮点值。为了进行排序,所有 NaN 值都被认为是等效且相等的。
该排序算法是一个经过调优的快速排序法,改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能,这导致其他快速排序会降低二次型性能。
a
- 要排序的数组fromIndex
- 要排序的第一个元素的索引(包括)toIndex
- 要排序的最后一个元素的索引(不包括)
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static void sort(Object[] a)
Comparable
接口。此外,数组中的所有元素都必须是可相互比较的(也就是说,对于数组中的任何 e1 和 e2 元素而言,e1.compareTo(e2) 不得抛出 ClassCastException)。保证此排序是稳定的:不会因调用 sort 方法而对相等的元素进行重新排序。
该排序算法是一个经过修改的合并排序算法(其中,如果低子列表中的最高元素小于高子列表中的最低元素,则忽略合并)。此算法提供可保证的 n*log(n) 性能。
a
- 要排序的数组
ClassCastException
- 如果数组包含不可相互比较的 的元素(例如,字符串和整数)。public static void sort(Object[] a, int fromIndex, int toIndex)
Comparable
接口。此外,此范围中的所有元素都必须是可相互比较的(也就是说,对于数组中的任何 e1 和 e2 元素而言,e1.compareTo(e2) 不得抛出 ClassCastException)。保证此排序是稳定的:不会因调用 sort 方法而对相等的元素进行重新排序。
该排序算法是一个经过修改的合并排序算法(其中,如果低子列表中的最高元素小于高子列表中的最低元素,则忽略合并)。此算法提供可保证的 n*log(n) 性能。
a
- 要排序的数组fromIndex
- 要排序的第一个元素的索引(包括)toIndex
- 要排序的最后一个元素的索引(不包括)
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
ClassCastException
- 如果数组包含不可相互比较的 的元素(例如,字符串和整数)。public static <T> void sort(T[] a, Comparator<? super T> c)
保证此排序是稳定的:不会因调用 sort 方法而对相等的元素进行重新排序。
该排序算法是一个经过修改的合并排序算法(其中,如果低子列表中的最高元素小于高子列表中的最低元素,则忽略合并)。此算法提供可保证的 n*log(n) 性能。
a
- 要排序的数组c
- 确定数组顺序的比较器。null 值指示应该使用元素的自然顺序。
ClassCastException
- 如果数组包含使用指定的比较器不可相互比较的 的元素。public static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
保证此排序是稳定的:不会因调用 sort 方法而对相等的元素进行重新排序。
该排序算法是一个经过修改的合并排序算法(其中,如果低子列表中的最高元素小于高子列表中的最低元素,则忽略合并)。此算法提供可保证的 n*log(n) 性能。
a
- 要排序的数组fromIndex
- 要排序的第一个元素的索引(包括)toIndex
- 要排序的最后一个元素的索引(不包括)c
- 确定数组顺序的比较器。null 值指示应该使用元素的自然顺序。
ClassCastException
- 如果数组包含使用指定的比较器不可相互比较的 的元素。
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static int binarySearch(long[] a, long key)
sort(long[])
方法)。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个带有指定值的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组key
- 要搜索的值
public static int binarySearch(long[] a, int fromIndex, int toIndex, long key)
sort(long[], int, int)
方法)。如果没有对范围进行排序,则结果是不确定的。如果范围包含多个带有指定值的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组fromIndex
- 要搜索的第一个元素的索引(包括)toIndex
- 要搜索的最后一个元素的索引(不包括)key
- 要搜索的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static int binarySearch(int[] a, int key)
sort(int[])
方法)。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个带有指定值的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组key
- 要搜索的值
public static int binarySearch(int[] a, int fromIndex, int toIndex, int key)
sort(int[], int, int)
方法)。如果没有对范围进行排序,则结果是不确定的。如果范围包含多个带有指定值的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组fromIndex
- 要搜索的第一个元素的索引(包括)toIndex
- 要搜索的最后一个元素的索引(不包括)key
- 要搜索的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static int binarySearch(short[] a, short key)
sort(short[])
方法)。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个带有指定值的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组key
- 要搜索的值
public static int binarySearch(short[] a, int fromIndex, int toIndex, short key)
sort(short[], int, int)
方法)。如果没有对范围进行排序,则结果是不确定的。如果范围包含多个带有指定值的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组fromIndex
- 要搜索的第一个元素的索引(包括)toIndex
- 要搜索的最后一个元素的索引(不包括)key
- 要搜索的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static int binarySearch(char[] a, char key)
sort(char[])
方法)。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个带有指定值的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组key
- 要搜索的值
public static int binarySearch(char[] a, int fromIndex, int toIndex, char key)
sort(char[], int, int)
方法)。如果没有对范围进行排序,则结果是不确定的。如果范围包含多个带有指定值的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组fromIndex
- 要搜索的第一个元素的索引(包括)toIndex
- 要搜索的最后一个元素的索引(不包括)key
- 要搜索的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static int binarySearch(byte[] a, byte key)
sort(byte[])
方法)。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个带有指定值的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组key
- 要搜索的值
public static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
sort(byte[], int, int)
方法)。如果没有对范围进行排序,则结果是不确定的。如果范围包含多个带有指定值的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组fromIndex
- 要搜索的第一个元素的索引(包括)toIndex
- 要搜索的最后一个元素的索引(不包括)key
- 要搜索的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static int binarySearch(double[] a, double key)
sort(double[])
方法)。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个带有指定值的元素,则无法保证找到的是哪一个。此方法认为所有 NaN 值都是等效且相等的。
a
- 要搜索的数组key
- 要搜索的值
public static int binarySearch(double[] a, int fromIndex, int toIndex, double key)
sort(double[], int, int)
方法)。如果没有对范围进行排序,则结果是不确定的。如果范围包含多个带有指定值的元素,则无法保证找到的是哪一个。此方法认为所有 NaN 值都是等效且相等的。
a
- 要搜索的数组fromIndex
- 要搜索的第一个元素的索引(包括)toIndex
- 要搜索的最后一个元素的索引(不包括)key
- 要搜索的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static int binarySearch(float[] a, float key)
sort(float[])
方法)。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个带有指定值的元素,则无法保证找到的是哪一个。此方法认为所有 NaN 值都是等效且相等的。
a
- 要搜索的数组key
- 要搜索的值
public static int binarySearch(float[] a, int fromIndex, int toIndex, float key)
sort(float[], int, int)
方法)。如果没有对范围进行排序,则结果是不确定的。如果范围包含多个带有指定值的元素,则无法保证找到的是哪一个。此方法认为所有 NaN 值都是等效且相等的。
a
- 要搜索的数组fromIndex
- 要搜索的第一个元素的索引(包括)toIndex
- 要搜索的最后一个元素的索引(不包括)key
- 要搜索的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static int binarySearch(Object[] a, Object key)
sort(Object[])
方法)。如果没有对数组进行排序,则结果是不确定的。(如果数组包含不可相互比较的元素(例如,字符串和整数),则无法 根据其元素的自然顺序对数组进行排序,因此结果是不确定的。)如果数组包含多个等于指定对象的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组key
- 要搜索的值
ClassCastException
- 如果搜索的键不能与数组的元素进行比较。public static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
sort(Object[], int, int)
方法)。如果没有对范围进行排序,则结果是不确定的。(如果范围包含不可相互比较的元素,例如,字符串和整数,则无法 根据其元素的自然顺序对范围进行排序,因此结果是不确定的。)如果范围包含多个等于指定对象的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组fromIndex
- 要搜索的第一个元素的索引(包括)toIndex
- 要搜索的最后一个元素的索引(不包括)key
- 要搜索的值
ClassCastException
- 如果搜索的键不能与数组的指定范围内的元素进行比较。
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)
sort(T[], Comparator)
方法)对数组进行升序排序。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个等于指定对象的元素,则无法保证找到的是哪一个。
a
- 要搜索的数组key
- 要搜索的值c
- 用来对数组进行排序的比较器。null 值指示应该使用元素的自然顺序。
ClassCastException
- 如果数组包含使用指定的比较器不可相互比较 的元素,或者使用此比较器无法相互比较搜索键与数组的元素。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 值指示应该使用元素的自然顺序。
ClassCastException
- 如果范围包含使用指定的比较器不可相互比较 的元素,或者使用此比较器无法相互比较搜索键与范围中的元素。
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static boolean equals(long[] a, long[] a2)
a
- 将测试其相等性的一个数组a2
- 将测试其相等性的另一个数组
public static boolean equals(int[] a, int[] a2)
a
- 将测试其相等性的一个数组a2
- 将测试其相等性的另一个数组
public static boolean equals(short[] a, short[] a2)
a
- 将测试其相等性的一个数组a2
- 将测试其相等性的另一个数组
public static boolean equals(char[] a, char[] a2)
a
- 将测试其相等性的一个数组a2
- 将测试其相等性的另一个数组
public static boolean equals(byte[] a, byte[] a2)
a
- 将测试其相等性的一个数组a2
- 将测试其相等性的另一个数组
public static boolean equals(boolean[] a, boolean[] a2)
a
- 将测试其相等性的一个数组a2
- 将测试其相等性的另一个数组
public static boolean equals(double[] a, double[] a2)
如果以下条件成立,则认为两个 double 型数组 d1 和 d2 是相等的:
new Double(d1).equals(new Double(d2))(与 == 操作符不同,此方法认为 NaN 等于它本身,而 0.0d 不等于 -0.0d。)
a
- 将测试其相等性的一个数组a2
- 将测试其相等性的另一个数组
Double.equals(Object)
public static boolean equals(float[] a, float[] a2)
如果以下条件成立,则认为两个 float 型数组 f1 和 f2 是相等的:
new Float(f1).equals(new Float(f2))(与 == 操作符不同,此方法认为 NaN 等于它本身,而 0.0f 不等于 -0.0f。)
a
- 将测试其相等性的一个数组a2
- 将测试其相等性的另一个数组
Float.equals(Object)
public static boolean equals(Object[] a, Object[] a2)
a
- 将测试其相等性的一个数组a2
- 将测试其相等性的另一个数组
public static void fill(long[] a, long val)
a
- 要填充的数组val
- 要存储在数组所有元素中的值public static void fill(long[] a, int fromIndex, int toIndex, long val)
a
- 要填充的数组fromIndex
- 要使用指定值填充的第一个元素的索引(包括)toIndex
- 要使用指定值填充的最后一个元素的索引(不包括)val
- 要存储在数组所有元素中的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static void fill(int[] a, int val)
a
- 要填充的数组val
- 要存储在数组所有元素中的值public static void fill(int[] a, int fromIndex, int toIndex, int val)
a
- 要填充的数组fromIndex
- 要使用指定值填充的第一个元素的索引(包括)toIndex
- 要使用指定值填充的最后一个元素的索引(不包括)val
- 要存储在数组所有元素中的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static void fill(short[] a, short val)
a
- 要填充的数组val
- 要存储在数组所有元素中的值public static void fill(short[] a, int fromIndex, int toIndex, short val)
a
- 要填充的数组fromIndex
- 要使用指定值填充的第一个元素的索引(包括)toIndex
- 要使用指定值填充的最后一个元素的索引(不包括)val
- 要存储在数组所有元素中的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static void fill(char[] a, char val)
a
- 要填充的数组val
- 要存储在数组所有元素中的值public static void fill(char[] a, int fromIndex, int toIndex, char val)
a
- 要填充的数组fromIndex
- 要使用指定值填充的第一个元素的索引(包括)toIndex
- 要使用指定值填充的最后一个元素的索引(不包括)val
- 要存储在数组所有元素中的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static void fill(byte[] a, byte val)
a
- 要填充的数组val
- 要存储在数组所有元素中的值public static void fill(byte[] a, int fromIndex, int toIndex, byte val)
a
- 要填充的数组fromIndex
- 要使用指定值填充的第一个元素的索引(包括)toIndex
- 要使用指定值填充的最后一个元素的索引(不包括)val
- 要存储在数组所有元素中的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static void fill(boolean[] a, boolean val)
a
- 要填充的数组val
- 要存储在数组所有元素中的值public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)
a
- 要填充的数组fromIndex
- 要使用指定值填充的第一个元素的索引(包括)toIndex
- 要使用指定值填充的最后一个元素的索引(不包括)val
- 要存储在数组所有元素中的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static void fill(double[] a, double val)
a
- 要填充的数组val
- 要存储在数组所有元素中的值public static void fill(double[] a, int fromIndex, int toIndex, double val)
a
- 要填充的数组fromIndex
- 要使用指定值填充的第一个元素的索引(包括)toIndex
- 要使用指定值填充的最后一个元素的索引(不包括)val
- 要存储在数组所有元素中的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static void fill(float[] a, float val)
a
- 要填充的数组val
- 要存储在数组所有元素中的值public static void fill(float[] a, int fromIndex, int toIndex, float val)
a
- 要填充的数组fromIndex
- 要使用指定值填充的第一个元素的索引(包括)toIndex
- 要使用指定值填充的最后一个元素的索引(不包括)val
- 要存储在数组所有元素中的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
public static void fill(Object[] a, Object val)
a
- 要填充的数组val
- 要存储在数组所有元素中的值
ArrayStoreException
- 如果指定值不是可存储在指定数组中的运行时类型public static void fill(Object[] a, int fromIndex, int toIndex, Object val)
a
- 要填充的数组fromIndex
- 要使用指定值填充的第一个元素的索引(包括)toIndex
- 要使用指定值填充的最后一个元素的索引(不包括)val
- 要存储在数组的所有元素中的值
IllegalArgumentException
- 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException
- 如果 fromIndex < 0 或 toIndex > a.length
ArrayStoreException
- 如果指定值不是可存储在指定数组中的运行时类型public static <T> T[] copyOf(T[] original, int newLength)
original
- 要复制的数组newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果 newLength 为负
NullPointerException
- 如果 original 为 nullpublic static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)
original
- 要复制的数组newLength
- 要返回的副本的长度newType
- 要返回的副本的类
NegativeArraySizeException
- 如果 newLength 为负
NullPointerException
- 如果 original 为 null
ArrayStoreException
- 如果从 original 中复制的元素不属于存储在 newType 类数组中的运行时类型public static byte[] copyOf(byte[] original, int newLength)
original
- 要复制的数组newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果 newLength 为负
NullPointerException
- 如果 original 为 nullpublic static short[] copyOf(short[] original, int newLength)
original
- 要复制的数组newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果 newLength 为负
NullPointerException
- 如果 original 为 nullpublic static int[] copyOf(int[] original, int newLength)
original
- 要复制的数组newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果 newLength 为负
NullPointerException
- 如果 original 为 nullpublic static long[] copyOf(long[] original, int newLength)
original
- 要复制的数组newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果 newLength 为负
NullPointerException
- 如果 original 为 nullpublic static char[] copyOf(char[] original, int newLength)
original
- 要复制的数组newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果 newLength 为负
NullPointerException
- 如果 original 为 nullpublic static float[] copyOf(float[] original, int newLength)
original
- 要复制的数组newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果 newLength 为负
NullPointerException
- 如果 original 为 nullpublic static double[] copyOf(double[] original, int newLength)
original
- 要复制的数组newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果 newLength 为负
NullPointerException
- 如果 original 为 nullpublic static boolean[] copyOf(boolean[] original, int newLength)
original
- 要复制的数组newLength
- 要返回的副本的长度
NegativeArraySizeException
- 如果 newLength 为负
NullPointerException
- 如果 original 为 nullpublic static <T> T[] copyOfRange(T[] original, int from, int to)
所得数组与原数组属于完全相同的类。
original
- 将要从其复制一个范围的数组from
- 要复制的范围的初始索引(包括)to
- 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
ArrayIndexOutOfBoundsException
- 如果 from < 0 或 from > original.length()
IllegalArgumentException
- 如果 from > to
NullPointerException
- 如果 original 为 nullpublic static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)
original
- 将要从其复制一个范围的数组from
- 要复制的范围的初始索引(包括)to
- 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。newType
- 要返回的副本的类
ArrayIndexOutOfBoundsException
- 如果 from < 0 或 from > original.length()
IllegalArgumentException
- 如果 from > to
NullPointerException
- 如果 original 为 null
ArrayStoreException
- 如果从 original 复制的元素不属于可以存储在 newType 类数组中的运行时类型。public static byte[] copyOfRange(byte[] original, int from, int to)
original
- 将要从其复制一个范围的数组from
- 要复制的范围的初始索引(包括)to
- 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
ArrayIndexOutOfBoundsException
- 如果 from < 0 或 from > original.length()
IllegalArgumentException
- 如果 from > to
NullPointerException
- 如果 original 为 nullpublic static short[] copyOfRange(short[] original, int from, int to)
original
- 将要从其复制一个范围的数组from
- 要复制的范围的初始索引(包括)to
- 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
ArrayIndexOutOfBoundsException
- 如果 from < 0 或 from > original.length()
IllegalArgumentException
- 如果 from > to
NullPointerException
- 如果 original 为 nullpublic static int[] copyOfRange(int[] original, int from, int to)
original
- 将要从其复制一个范围的数组from
- 要复制的范围的初始索引(包括)to
- 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
ArrayIndexOutOfBoundsException
- 如果 from < 0 或 from > original.length()
IllegalArgumentException
- 如果 from > to
NullPointerException
- 如果 original 为 nullpublic static long[] copyOfRange(long[] original, int from, int to)
original
- 将要从其复制一个范围的数组from
- 要复制的范围的初始索引(包括)to
- 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
ArrayIndexOutOfBoundsException
- 如果 from < 0 或 from > original.length()
IllegalArgumentException
- 如果 from > to
NullPointerException
- 如果 original 为 nullpublic static char[] copyOfRange(char[] original, int from, int to)
original
- 将要从其复制一个范围的数组from
- 要复制的范围的初始索引(包括)to
- 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
ArrayIndexOutOfBoundsException
- 如果 from < 0 或 from > original.length()
IllegalArgumentException
- 如果 from > to
NullPointerException
- 如果 original 为 nullpublic static float[] copyOfRange(float[] original, int from, int to)
original
- 将要从其复制一个范围的数组from
- 要复制的范围的初始索引(包括)to
- 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
ArrayIndexOutOfBoundsException
- 如果 from < 0 或 from > original.length()
IllegalArgumentException
- 如果 from > to
NullPointerException
- 如果 original 为 nullpublic static double[] copyOfRange(double[] original, int from, int to)
original
- 将要从其复制一个范围的数组from
- 要复制的范围的初始索引(包括)to
- 要复制的范围的最后索引(不包括)。(此索引可能位于数组范围之外)。
ArrayIndexOutOfBoundsException
- 如果 from < 0 或 from > original.length()
IllegalArgumentException
- 如果 from > to
NullPointerException
- 如果 original 为 nullpublic static boolean[] copyOfRange(boolean[] original, int from, int to)
original
- 将要从其复制一个范围的数组from
- 要复制的范围的初始索引(包括)to
- 要复制的范围的最后索引(不包括)。(此索引可能位于数组范围之外)。
ArrayIndexOutOfBoundsException
- 如果 from < 0 或 from > original.length()
IllegalArgumentException
- 如果 from > to
NullPointerException
- 如果 original 为 nullpublic static <T> List<T> asList(T... a)
Collection.toArray()
一起,充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的,并且实现了 RandomAccess
。
此方法还提供了一个创建固定长度的列表的便捷方法,该列表被初始化为包含多个元素:
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
a
- 支持列表的数组。
public static int hashCode(long[] a)
此方法返回的值与在 List
上调用 hashCode
方法获得的值相同,该 List 包含以相同顺序表示 a 数组元素的 Long
实例的序列。如果 a 为 null,则此方法返回 0。
a
- 要计算其哈希值的数组
public static int hashCode(int[] a)
此方法返回的值与在 List
上调用 hashCode
方法获得的值相同,该 List 包含以相同顺序表示 a 数组元素的 Integer
实例的序列。如果 a 为 null,则此方法返回 0。
a
- 要计算其哈希值的数组
public static int hashCode(short[] a)
此方法返回的值与在 List
上调用 hashCode
方法获得的值相同,该 List 包含以相同顺序表示 a 数组元素的 Short
实例的序列。如果 a 为 null,则此方法返回 0。
a
- 要计算其哈希值的数组
public static int hashCode(char[] a)
此方法返回的值与在 List
上调用 hashCode
方法获得的值相同,该 List 包含以相同顺序表示 a 数组元素的 Character
实例的序列。如果 a 为 null,则此方法返回 0。
a
- 要计算其哈希值的数组
public static int hashCode(byte[] a)
此方法返回的值与在 List
上调用 hashCode
方法获得的值相同,该 List 包含以相同顺序表示 a 数组元素的 Byte
实例的序列。如果 a 为 null,则此方法返回 0。
a
- 要计算其哈希值的数组
public static int hashCode(boolean[] a)
此方法返回的值与在 List
上调用 hashCode
方法获得的值相同,该 List 包含以相同顺序表示 a 数组元素的 Boolean
实例的序列。如果 a 为 null,则此方法返回 0。
a
- 要计算其哈希值的数组
public static int hashCode(float[] a)
此方法返回的值与在 List
上调用 hashCode
方法获得的值相同,该 List 包含以相同顺序表示 a 数组元素的 Float
实例的序列。如果 a 为 null,则此方法返回 0。
a
- 要计算其哈希值的数组
public static int hashCode(double[] a)
此方法返回的值与在 List
上调用 hashCode
方法获得的值相同,该 List 包含以相同顺序表示 a 数组元素的 Double
实例的序列。如果 a 为 null,则此方法返回 0。
a
- 要计算其哈希值的数组
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
- 将计算其基于内容的哈希码的数组
deepHashCode(Object[])
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
- 将计算其基于深层内容的哈希码的数组
hashCode(Object[])
public static boolean deepEquals(Object[] a1, Object[] a2)
equals(Object[],Object[])
方法不同,此方法适用于任意深度的嵌套数组。
如果两个数组引用均为 null,或者它们引用了包含相同元素数量的数组,并且两个数组中的所有相应元素对都是深层相等的,则认为这两个数组引用是深层相等的。
如果满足以下任意条件之一,则两个 null 元素 e1 和 e2 可能是深层相等的:
如果指定数组中的任意一个数组,直接或间接通过一个或多个数组级别,包含数组本身作为其元素,则此方法的行为是不确定的。
a1
- 将测试其相等性的一个数组a2
- 将测试其相等性的另一个数组
equals(Object[],Object[])
public static String toString(long[] a)
a
- 返回其字符串表示形式的数组
public static String toString(int[] a)
a
- 返回其字符串表示形式的数组
public static String toString(short[] a)
a
- 返回其字符串表示形式的数组
public static String toString(char[] a)
a
- 返回其字符串表示形式的数组
public static String toString(byte[] a)
a
- 返回其字符串表示形式的数组
public static String toString(boolean[] a)
a
- 返回其字符串表示形式的数组
public static String toString(float[] a)
a
- 返回其字符串表示形式的数组
public static String toString(double[] a)
a
- 返回其字符串表示形式的数组
public static String toString(Object[] a)
Object.toString()
方法将它们转换为字符串,这描述了它们的标识,而不是它们的内容。
此方法返回的值等于 Arrays.asList(a).toString() 返回的值,除非 a 为 null,在这种情况下返回 "null"。
a
- 返回其字符串表示形式的数组
deepToString(Object[])
public static String deepToString(Object[] a)
字符串表示形式由数组的元素列表组成,括在方括号("[]")中。相邻元素用字符 ", "(逗号加空格)分隔。这些元素通过 String.valueOf(Object) 转换为字符串,除非它们是自身的数组。
如果元素 e 是一个基本类型的数组,则通过调用 Arrays.toString(e) 的适当重载将它转换为字符串。如果元素 e 是一个引用类型的数组,则通过递归调用此方法将它转换为字符串。
为了避免无限递归,如果指定数组包含本身作为其元素,或者包含通过一个或多个数组级别对其自身的间接引用,则将自引用转换为字符串 "[...]"。例如,只包含对自身进行引用的数组将呈现为 "[[...]]"。
如果指定数组为 null,则此方法返回 "null"。
a
- 返回其字符串表示形式的数组
toString(Object[])
|
JavaTM 2 Platform Standard Ed. 6 |
|||||||||
上一个类 下一个类 | 框架 无框架 | |||||||||
摘要: 嵌套 | 字段 | 构造方法 | 方法 | 详细信息: 字段 | 构造方法 | 方法 |
版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。