Arrays (Java 2 Platform SE 5.0)
function windowTitle()
{
parent.document.title="Arrays (Java 2 Platform SE 5.0)";
}
概述
软件包
类
使用
树
已过时
索引
帮助
JavaTM 2 PlatformStandard Ed. 5.0
上一个类
下一个类
框架
无框架
!--
if(window==top) {
document.writeln('所有类');
}
//--
所有类
摘要： 嵌套 | 字段 | 构造方法 | 方法
详细信息： 字段 | 构造方法 | 方法
java.util
类 Arrays
https://www.doczj.com/doc/fc2760958.html,ng.Object
java.util.Arrays
public class Arraysextends Object
此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。
此类中所含方法的文档都包括对实现 的简短描述。应该将这些描述视为实现注意事项，而不应将它们视为规范 的一部分。实现者应该可以随意替代其他算法，只要遵循规范本身即可。（例如，sort(Object[]) 使用的算法不必是一个合并排序算法，但它必须是稳定的。）
此类是 Java Collections Framework 的成员。
从以下版本开始：
1.2
另请参见：Comparable,
Comparator
方法摘要
static
<T> List<T>
asList(T... a)
返回一个受指定数组支持的固定大小的列表。
static int
binarySearch(byte[] a,
byte key)
使用二进制搜索算法来搜索指定的 byte 型数组，以获得指定的值。
static int
binarySearch(char[] a,
char key)
使用二进制搜索算法来搜索指定的 char 型数组，以获得指定的值。
static int
binarySearch(double[] a,
double key)
使用二进制搜索算法来搜索指定的 double 型数组，以获得指定的值。
static int
binarySearch(float[] a,
float key)
使用二进制搜索算法来搜索指定的 float 型数组，以获得指定的值。
static int
binarySearch(int[] a,
int key)
使用二进制搜索算法来搜索指定的 int 型数组，以获得指定的值。
static int
binarySearch(long[] a,
long key)
&n
bsp; 使用二进制搜索算法来搜索指定的 long 型数组，以获得指定的值。
static int
binarySearch(Object[] a,
Object key)
使用二进制搜索算法来搜索指定数组，以获得指定对象。
static int
binarySearch(short[] a,
short key)
使用二进制搜索算法来搜索指定的 short 型数组，以获得指定的值。
static
<T> int
binarySearch(T[] a,
T key,
Comparator<? super T> c)
使用二进制搜索算法来搜索指定数组，以获得指定对象。
static boolean
deepEquals(Object[] a1,
Object[] a2)
如果两个指定数组彼此是深层相等 的，则返回 true。
static int
deepHashCode(Object[] a)
基于指定数组的“深层内容”返回哈希码。
static String
deepToString(Object[] a)
返回指定数组“深层内容”的字符串表示形式。
static boolean
equals(boolean[] a,
boolean[] a2)
如果两个指定的 boolean 型数组彼此相等，则返回 true。
static boolean
equals(byte[] a,
byte[] a2)
如果两个指定的 byte 型数组彼此相等，则返回 true。
static boolean
equals(char[] a,
char[] a2)
如果两个指定的 char 型数组彼此相等，则返回 true。
static boolean
equals(double[] a,
double[] a2)
如果两个指定的 double 型数组彼此相等，则返回 true。
static boolean
equals(float[] a,
float[] a2)
如果两个指定的 float 型数组彼此相等，则返回 true。
static boolean
equals(int[] a,
int[] a2)
如果两个指定的 int 型数组彼此相等，则返回 true。
static boolean
equals(long[] a,
long[] a2)
如果两个指定的 long 型数组彼此相等，则返回 true。
static boolean
equals(Object[] a,
Object[] a2)
如果两个指定的 Objects 数组彼此相等，
则返回 true。
static boolean
equals(short[] a,
short[] a2)
如果两个指定的 short 型数组彼此相等，则返回 true。
static void
fill(boolean[] a,
boolean val)
将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
static void
fill(boolean[] a,
int fromIndex,
int toIndex,
boolean val)
将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。
static void
fill(byte[] a,
byte val)
将指定的 byte 值分配给指定 byte 节型数组的每个元素。
static void
fill(byte[] a,
int fromIndex,
int toIndex,
byte val)
将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。
static void
fill(char[] a,
char val)
将指定的 char 值分配给指定 char 型数组的每个元素。
static void
fill(char[] a,
int fromIndex,
int toIndex,
char val)
将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。
static void
fill(double[] a,
double val)
将指定的 double 值分配给指定 double 型数组的每个元素。
static void
fill(double[] a,
int fromIndex,
int toIndex,
double val)
将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。
static void
fill(float[] a,
float val)
将指定的 float 值分配给指定 float 型数组的每个元素。
static void
fill(float[] a,
int fromIndex,
int toIndex,
float val)
将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。
static void
fill(int[] a,
int val)
将指定的 int 值分配给指定 int 型数组的每个元素。
static void
fill(int[] a,
int fromIndex,
int toIndex,
int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
static void
fill(long[] a,
int fr
omIndex,
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)
根据指定比较器产生的顺序对指定对象数组进行排序。
s
tatic
<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)
返回指定数组内容的字符串表示形式。
从类 https://www.doczj.com/doc/fc2760958.html,ng.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
方法详细信息
sort
public static void sort(long[] a)
对指定的 long 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。
sort
public static void sort(long[] a,
int fromIndex,
int toIndex)
对指定 long 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上
提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。fromIndex - 要排序的第一个元素的索引（包括）。toIndex - 要排序的最后一个元素的索引（不包括）。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
sort
public static void sort(int[] a)
对指定的 int 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。
sort
public static void sort(int[] a,
int fromIndex,
int toIndex)
对指定 int 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》 Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。fromIndex - 要排序的第一个元素的索引（包括）。toIndex - 要排序的最后一个元素的索引（不包括）。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
sort
public static void sort(short[] a)
对指定的 short 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。
sort
public static void sort(short[] a,
int fromIndex,
int toIndex)
对指定 short 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导
致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。fromIndex - 要排序的第一个元素的索引（包括）。toIndex - 要排序的最后一个元素的索引（不包括）。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
sort
public static void sort(char[] a)
对指定的 char 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。
sort
public static void sort(char[] a,
int fromIndex,
int toIndex)
对指定 char 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。fromIndex - 要排序的第一个元素的索引（包括）。toIndex - 要排序的最后一个元素的索引（不包括）。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
sort
public static void sort(byte[] a)
对指定的 byte 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。
sort
public static void sort(byte[] a,
int fromIndex,
int toIndex)
对指定 byte 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低
二次型性能。
参数：a - 要排序的数组。fromIndex - 要排序的第一个元素的索引（包括）。toIndex - 要排序的最后一个元素的索引（不包括）。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
sort
public static void sort(double[] a)
对指定的 double 型数组按数字升序进行排序。
虽然 < 关系式对不同数字 -0.0 == 0.0 返回的结果为 true，并且认为 NaN 值既不小于或大于任何浮点值，也不等于任何浮点值，甚至不等于它自身。但 < 关系式不能提供所有浮点值的整体排序。为了允许进行排序，此方法不使用 < 关系式来确定数字升序排序，而是利用 https://www.doczj.com/doc/fc2760958.html,pareTo(https://www.doczj.com/doc/fc2760958.html,ng.Double) 来完成整体排序。此排序法不同于 < 关系式，其中 -0.0 被认为是小于 0.0 的值，并且 NaN 被认为大于其他任何浮点值。为了进行排序，所有 NaN 值都被认为是等效且相等的。
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》 Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。
sort
public static void sort(double[] a,
int fromIndex,
int toIndex)
对指定 double 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）
虽然 < 关系式对不同数字 -0.0 == 0.0 返回的结果为 true，并且认为 NaN 值既不小于或大于任何浮点值，也不等于任何浮点值，甚至不等于它自身。但 < 关系式不能提供所有浮点值的整体排序。为了允许进行排序，此方法不使用 < 关系式来确定数字升序排序，而是利用 https://www.doczj.com/doc/fc2760958.html,pareTo(https://www.doczj.com/doc/fc2760958.html,ng.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
Arr
ayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
sort
public static void sort(float[] a)
对指定的 float 型数组按数字升序进行排序。
虽然 < 关系式对不同数字 -0.0f == 0.0f 返回的结果为 true，并且认为 NaN 值既不小于或大于任何浮点值，也不等于任何浮点值，甚至不等于它自身。但 < 关系式不能提供所有浮点值的整体排序。为了允许进行排序，此方法不使用 < 关系式来确定数字升序排序，而是利用 https://www.doczj.com/doc/fc2760958.html,pareTo(https://www.doczj.com/doc/fc2760958.html,ng.Float) 来完成整体排序。此排序法不同于 < 关系式，其中 -0.0f 被认为是小于 0.0f 的值，并且 NaN 被认为大于其他任何浮点值。为了进行排序，所有 NaN 值都被认为是等效且相等的。
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》 Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。
sort
public static void sort(float[] a,
int fromIndex,
int toIndex)
对指定 float 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）
虽然 < 关系式对不同数字 -0.0f == 0.0f 返回的结果为 true，并且认为 NaN 值既不小于或大于任何浮点值，也不等于任何浮点值，甚至不等于它自身。但 < 关系式不能提供所有浮点值的整体排序。为了允许进行排序，此方法不使用 < 关系式来确定数字升序排序，而是利用 https://www.doczj.com/doc/fc2760958.html,pareTo(https://www.doczj.com/doc/fc2760958.html,ng.Float) 来完成整体排序。此排序法不同于 < 关系式，其中 -0.0f 被认为是小于 0.0f 的值，并且 NaN 被认为大于其他任何浮点值。为了进行排序，所有 NaN 值都被认为是等效且相等的。
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的《Engineering a Sort Function", Software-Practice and Experience》Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：a - 要排序的数组。fromIndex - 要排序的第一个元素的索引（包括）。toIndex - 要排序的最后一个元素的索引（不包括）。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
sort
public static void sort(Object[] a)
根据元素的自然顺序，对指定对象数组按升序进行排序。数组中的所有元素都必须实现 Compara
ble 接口。此外，数组中的所有元素都必须是可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言，https://www.doczj.com/doc/fc2760958.html,pareTo(e2) 不得抛出 ClassCastException）。
保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。
该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。
参数：a - 要排序的数组。
抛出：
ClassCastException - 如果数组包含不可相互比较的 的元素（例如，字符串和整数）。另请参见：Comparable
sort
public static void sort(Object[] a,
int fromIndex,
int toIndex)
根据元素的自然顺序，对指定对象数组的指定范围按升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）此范围中的所有元素都必须实现 Comparable 接口。此外，此范围中的所有元素都必须是可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言，https://www.doczj.com/doc/fc2760958.html,pareTo(e2) 不得抛出 ClassCastException）。
保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。
该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。
参数：a - 要排序的数组。fromIndex - 要排序的第一个元素的索引（包括）。toIndex - 要排序的最后一个元素的索引（不包括）。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
ClassCastException - 如果数组包含不可相互比较的 的元素（例如，字符串和整数）。另请参见：Comparable
sort
public static <T> void sort(T[] a,
Comparator<? super T> c)
根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言，https://www.doczj.com/doc/fc2760958.html,pare(e1, e2) 不得抛出 ClassCastException）。
保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。
该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。
参数：a - 要排序的数组。c - 确定数组顺序的比较器。null 值指示应该使用元素的自然顺序。
抛出：
ClassCastException - 如果数组包含使用指定的比较器不可相互比
较的 的元素。另请参见：Comparator
sort
public static <T> void sort(T[] a,
int fromIndex,
int toIndex,
Comparator<? super T> c)
根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）此范围内的所有元素都必须是通过指定比较器可相互比较的（也就是说，对于该范围中的任何 e1 和 e2 元素而言，https://www.doczj.com/doc/fc2760958.html,pare(e1, e2) 不得抛出 ClassCastException）。
保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。
该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。
参数：a - 要排序的数组。fromIndex - 要排序的第一个元素的索引（包括）。toIndex - 要排序的最后一个元素的索引（不包括）。c - 确定数组顺序的比较器。null 值指示应该使用元素的自然顺序。
抛出：
ClassCastException - 如果数组包含使用指定的比较器不可相互比较的 的元素。
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length另请参见：Comparator
binarySearch
public static int binarySearch(long[] a,
long key)
使用二进制搜索算法来搜索指定的 long 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
参数：a - 要搜索的数组。key - 要搜索的值。
返回：搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。另请参见：sort(long[])
binarySearch
public static int binarySearch(int[] a,
int key)
使用二进制搜索算法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
参数：a - 要搜索的数组。key - 要搜索的值。
返回：搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) -
1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。另请参见：sort(int[])
binarySearch
public static int binarySearch(short[] a,
short key)
使用二进制搜索算法来搜索指定的 short 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
参数：a - 要搜索的数组。key - 要搜索的值。
返回：搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。另请参见：sort(short[])
binarySearch
public static int binarySearch(char[] a,
char key)
使用二进制搜索算法来搜索指定的 char 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
参数：a - 要搜索的数组。key - 要搜索的值。
返回：搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。另请参见：sort(char[])
binarySearch
public static int binarySearch(byte[] a,
byte key)
使用二进制搜索算法来搜索指定的 byte 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
参数：a - 要搜索的数组。key - 要搜索的值。
返回：搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。另请参见：sort(byte[])
binarySearch
public static int binarySearch(double[] a,
double key)
使用二进制搜索算法来搜索指定的 double 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。此方法认为所有 NaN 值都是等效且相等的。
参数：a - 要搜索的数组。key - 要搜索的值。
返回：搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。另请参见：sort(double[])
binarySearch
public static int binarySearch(float[] a,
float key)
使用二进制搜索算法来搜索指定的 float 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过上面的 sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。此方法认为所有 NaN 值都是等效且相等的。
参数：a - 要搜索的数组。key - 要搜索的值。
返回：搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。另请参见：sort(float[])
binarySearch
public static int binarySearch(Object[] a,
Object key)
使用二进制搜索算法来搜索指定数组，以获得指定对象。在进行此调用之前，必须根据数组元素的自然顺序 对数组进行升序排序（通过上面的 Sort(Object[] 方法）。如果没有对数组进行排序，则结果是不明确的。（如果数组包含不可相互比较的元素（例如，字符串和整数），则无法 根据数组元素的自然顺序对数组进行排序，因此结果是不明确的。）如果数组包含多个等于指定对象的元素，则无法保证找到的是哪一个。
参数：a - 要搜索的数组。key - 要搜索的值。
返回：搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：
ClassCastException - 如果搜索的键不能与数组的元素进行比较。另请参见：Comparable,
sort(Object[])
binarySearch
public static <T> int binarySearch(T[] a,
T key,
Comparator<? super T> c)
使用二进制搜索算法来搜索指定数组，以获得指定对象。在进行此调用之前，必须根据指定的比较器（通过上面的 Sort(Object[]、Comparator) 方法）对数组进行升序排序。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个等于指定对象的元素，则无法保证找到的是哪一个。
参数：a - 要搜索的数组。key - 要搜索的值。c - 用来对数组进行排序的比较器。null 值指示应该使用元素的自然顺序。
返回：搜索键的索引，如果它包含在列表中；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：
ClassCastException - 如果数组包含使用指定的比较器不可相互比较 的元素，或者使用此比较器无法相互比较搜索键与数组的元素。另请参见：Comparable,
sort(Object[], Comparator)
equals
public static boolean equals(long[] a,
long[] a2)
如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。
参数：a - 将测试其相等性的一个数组。a2 - 将测试其相等性的另一个数组。
返回：如果两个数组相等，则返回 true。
equals
public static boolean equals(int[] a,
int[] a2)
如果两个指定的 int 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。
参数：a - 将测试其相等性的一个数组。a2 - 将测试其相等性的另一个数组。
返回：如果两个数组相等，则返回 true。
equals
public static boolean equals(short[] a,
short[] a2)
如果两个指定的 short 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元
素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。
参数：a - 将测试其相等性的一个数组。a2 - 将测试其相等性的另一个数组。
返回：如果两个数组相等，则返回 true。
equals
public static boolean equals(char[] a,
char[] a2)
如果两个指定的 char 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。
参数：a - 将测试其相等性的一个数组。a2 - 将测试其相等性的另一个数组。
返回：如果两个数组相等，则返回 true。
equals
public static boolean equals(byte[] a,
byte[] a2)
如果两个指定的 byte 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。
参数：a - 将测试其相等性的一个数组。a2 - 将测试其相等性的另一个数组。
返回：如果两个数组相等，则返回 true。
equals
public static boolean equals(boolean[] a,
boolean[] a2)
如果两个指定的 boolean 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。
参数：a - 将测试其相等性的一个数组。a2 - 将测试其相等性的另一个数组。
返回：如果两个数组相等，则返回 true。
equals
public static boolean equals(double[] a,
double[] a2)
如果两个指定的 double 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。
如果以下条件成立，则认为两个 double 型数组 d1 和 d2 是相等的：
new Double(d1).equals(new Double(d2))
（与 == 操作符不同，此方法认为 NaN 等于它本身，而 0.0d 不等于 -0.0d。）
参数：a -
将测试其相等性的一个数组。a2 - 将测试其相等性的另一个数组。
返回：如果两个数组相等，则返回 true。另请参见：Double.equals(Object)
equals
public static boolean equals(float[] a,
float[] a2)
如果两个指定的 float 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。
如果以下条件成立，则认为两个 float 型数组 f1 和 f2 是相等的：
new Float(f1).equals(new Float(f2))
（与 == 操作符不同，此方法认为 NaN 等于它本身，而 0.0f 不等于 -0.0f。）
参数：a - 将测试其相等性的一个数组。a2 - 将测试其相等性的另一个数组。
返回：如果两个数组相等，则返回 true。另请参见：Float.equals(Object)
equals
public static boolean equals(Object[] a,
Object[] a2)
如果两个指定的 Objects 数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。如果 (e1==null ? e2==null : e1.equals(e2))，则认为 e1 和 e2 这两个对象是相等的 。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。
参数：a - 将测试其相等性的一个数组。a2 - 将测试其相等性的另一个数组。
返回：如果两个数组相等，则返回 true。
fill
public static void fill(long[] a,
long val)
将指定的 long 值分配给指定 long 型数组的每个元素。
参数：a - 要填充的数组。val - 要存储在数组所有元素中的值。
fill
public static void fill(long[] a,
int fromIndex,
int toIndex,
long val)
将指定的 long 值分配给指定 long 型数组指定范围中的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则填充范围为空。）
参数：a - 要填充的数组。fromIndex - 要使用指定值填充的第一个元素的索引（包括）。toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。val - 要存储在数组所有元素中的值。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
fill
public static void fill(int[] a,
int val)
将指定的
int 值分配给指定 int 型数组的每个元素。
参数：a - 要填充的数组。val - 要存储在数组所有元素中的值。
fill
public static void fill(int[] a,
int fromIndex,
int toIndex,
int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则填充范围为空。）
参数：a - 要填充的数组。fromIndex - 要使用指定值填充的第一个元素的索引（包括）。toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。val - 要存储在数组所有元素中的值。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
fill
public static void fill(short[] a,
short val)
将指定的 short 值分配给指定 short 型数组的每个元素。
参数：a - 要填充的数组。val - 要存储在数组所有元素中的值。
fill
public static void fill(short[] a,
int fromIndex,
int toIndex,
short val)
将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则填充范围为空。）
参数：a - 要填充的数组。fromIndex - 要使用指定值填充的第一个元素的索引（包括）。toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。val - 要存储在数组所有元素中的值。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
fill
public static void fill(char[] a,
char val)
将指定的 char 值分配给指定 char 型数组的每个元素。
参数：a - 要填充的数组。val - 要存储在数组所有元素中的值。
fill
public static void fill(char[] a,
int fromIndex,
int toIndex,
char val)
将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则填充范围为空。）
参数：a - 要填充的数组。fromIndex - 要使用指定值填充的第一个元素的索引（包括）。toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。val - 要存储在数组所有元素中的值。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIn
dex < 0 或 toIndex > a.length
fill
public static void fill(byte[] a,
byte val)
将指定的 byte 值分配给指定 byte 节型数组的每个元素。
参数：a - 要填充的数组。val - 要存储在数组所有元素中的值。
fill
public static void fill(byte[] a,
int fromIndex,
int toIndex,
byte val)
将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则填充范围为空。）
参数：a - 要填充的数组。fromIndex - 要使用指定值填充的第一个元素的索引（包括）。toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。val - 要存储在数组所有元素中的值。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
fill
public static void fill(boolean[] a,
boolean val)
将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
参数：a - 要填充的数组。val - 要存储在数组所有元素中的值。
fill
public static void fill(boolean[] a,
int fromIndex,
int toIndex,
boolean val)
将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则填充范围为空。）
参数：a - 要填充的数组。fromIndex - 要使用指定值填充的第一个元素的索引（包括）。toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。val - 要存储在数组所有元素中的值。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
fill
public static void fill(double[] a,
double val)
将指定的 double 值分配给指定 double 型数组的每个元素。
参数：a - 要填充的数组。val - 要存储在数组所有元素中的值。
fill
public static void fill(double[] a,
int fromIndex,
int toIndex,
double val)
将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则填充范围为空。）
参数：a - 要填充的数组。fromIndex - 要使用指定值填充的第一个元素的索引（包括）。toIndex - 要使用指定值填充的最后一个元素的索
引（不包括）。val - 要存储在数组所有元素中的值。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
fill
public static void fill(float[] a,
float val)
将指定的 float 值分配给指定 float 型数组的每个元素。
参数：a - 要填充的数组。val - 要存储在数组所有元素中的值。
fill
public static void fill(float[] a,
int fromIndex,
int toIndex,
float val)
将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则填充范围为空。）
参数：a - 要填充的数组。fromIndex - 要使用指定值填充的第一个元素的索引（包括）。toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。val - 要存储在数组所有元素中的值。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
fill
public static void fill(Object[] a,
Object val)
将指定的 Object 引用分配给指定 Object 数组的每个元素。
参数：a - 要填充的数组。val - 要存储在数组所有元素中的值。
fill
public static void fill(Object[] a,
int fromIndex,
int toIndex,
Object val)
将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则填充范围为空。）
参数：a - 要填充的数组。fromIndex - 要使用指定值填充的第一个元素的索引（包括）。toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。val - 要存储在数组的所有元素中的值。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
asList
public static <T> List<T> asList(T... a)
返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直写”到数组。）此方法同 Collection.toArray 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。
此方法还提供了一个创建固定长度的列表的便捷方法，该列表被初始化为包含多个元素：
List stooges = Arrays.asList("Larry", "Moe", "Curly");
参数：a - 支持列表的数组。
返回：指定数组的列表视图