javatm platform
standard ed. 6

java.util
类 arrays

java.lang.object 继承者 java.util.arrays

public class arrays
extends object

此类包含用来操作数组(比如排序和搜索)的各种方法。此类还包含一个允许<yǔn xǔ>将数组作为列表来查看的静态工厂。

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

此类中所含方法的文档都包括<included>对实现 的简短描述。应该<yīng gāi>将这些描述视为实现注意<危险信号>事项,而不应将它们视为规范 的一部分。实现者应该<yīng gāi>可以< kě yǐ>随意替代其他<other>算法,只要遵循规范本身即可。(例如,sort(object[]) 使用的算法不必是一个合并排序算法,但它必须是稳定的。)

此类是 java collections framework 的成员。

从以下版本开始<appeared>:
1.2

方法摘要
static
<t> list<t>
aslist(t... a)
          返回一个受指定数组支持<support>的固定大小的列表。
static intbinarysearch(byte[] a,byte key)
          使用二分搜索法来搜索指定的 byte 型数组,以获得指定的值。
static intbinarysearch(byte[] a,int fromindex,int toindex,byte key)
          使用二分搜索法来搜索指定的 byte 型数组的范围,以获得指定的值。
static intbinarysearch(char[] a,char key)
          使用二分搜索法来搜索指定的 char 型数组,以获得指定的值。
static intbinarysearch(char[] a,int fromindex,int toindex,char key)
          使用二分搜索法来搜索指定的 char 型数组的范围,以获得指定的值。
static intbinarysearch(double[] a,double key)
          使用二分搜索法来搜索指定的 double 型数组,以获得指定的值。
static intbinarysearch(double[] a,int fromindex,int toindex,double key)
          使用二分搜索法来搜索指定的 double 型数组的范围,以获得指定的值。
static intbinarysearch(float[] a,float key)
          使用二分搜索法来搜索指定的 float 型数组,以获得指定的值。
static intbinarysearch(float[] a,int fromindex,int toindex,float key)
          使用二分搜索法来搜索指定的 float 型数组的范围,以获得指定的值。
static intbinarysearch(int[] a,int key)
          使用二分搜索法来搜索指定的 int 型数组,以获得指定的值。
static intbinarysearch(int[] a,int fromindex,int toindex,int key)
          使用二分搜索法来搜索指定的 int 型数组的范围,以获得指定的值。
static intbinarysearch(long[] a,int fromindex,int toindex,long key)
          使用二分搜索法来搜索指定的 long 型数组的范围,以获得指定的值。
static intbinarysearch(long[] a,long key)
          使用二分搜索法来搜索指定的 long 型数组,以获得指定的值。
static intbinarysearch(object[] a,int fromindex,int toindex,object key)
          使用二分搜索法来搜索指定数组的范围,以获得指定对象。
static intbinarysearch(object[] a,object key)
          使用二分搜索法来搜索指定数组,以获得指定对象。
static intbinarysearch(short[] a,int fromindex,int toindex,short key)
          使用二分搜索法来搜索指定的 short 型数组的范围,以获得指定的值。
static intbinarysearch(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 填充(如有必要),以使副本具有指定的长度< dù>。
static byte[]copyof(byte[] original,int newlength)
          复制指定的数组,截取或用 0 填充(如有必要),以使副本具有指定的长度< dù>。
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 booleandeepequals(object[] a1,object[] a2)
          如果两个指定数组彼此是深层相等 的,则返回 true
static intdeephashcode(object[] a)
          基于指定数组的“深层内容”返回哈希码。
static stringdeeptostring(object[] a)
          返回指定数组“深层内容”的字符串表示形式。
static booleanequals(boolean[] a,boolean[] a2)
          如果两个指定的 boolean 型数组彼此相等,则返回 true
static booleanequals(byte[] a,byte[] a2)
          如果两个指定的 byte 型数组彼此相等,则返回 true
static booleanequals(char[] a,char[] a2)
          如果两个指定的 char 型数组彼此相等,则返回 true
static booleanequals(double[] a,double[] a2)
          如果两个指定的 double 型数组彼此相等,则返回 true
static booleanequals(float[] a,float[] a2)
          如果两个指定的 float 型数组彼此相等,则返回 true
static booleanequals(int[] a,int[] a2)
          如果两个指定的 int 型数组彼此相等,则返回 true
static booleanequals(long[] a,long[] a2)
          如果两个指定的 long 型数组彼此相等,则返回 true
static booleanequals(object[] a,object[] a2)
          如果两个指定的 objects 数组彼此相等,则返回 true
static booleanequals(short[] a,short[] a2)
          如果两个指定的 short 型数组彼此相等,则返回 true
static voidfill(boolean[] a,boolean val)
          将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
static voidfill(boolean[] a,int fromindex,int toindex,boolean val)
          将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。
static voidfill(byte[] a,byte val)
          将指定的 byte 值分配给指定 byte 节型数组的每个元素。
static voidfill(byte[] a,int fromindex,int toindex,byte val)
          将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。
static voidfill(char[] a,char val)
          将指定的 char 值分配给指定 char 型数组的每个元素。
static voidfill(char[] a,int fromindex,int toindex,char val)
          将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。
static voidfill(double[] a,double val)
          将指定的 double 值分配给指定 double 型数组的每个元素。
static voidfill(double[] a,int fromindex,int toindex,double val)
          将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。
static voidfill(float[] a,float val)
          将指定的 float 值分配给指定 float 型数组的每个元素。
static voidfill(float[] a,int fromindex,int toindex,float val)
          将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。
static voidfill(int[] a,int val)
          将指定的 int 值分配给指定 int 型数组的每个元素。
static voidfill(int[] a,int fromindex,int toindex,int val)
          将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
static voidfill(long[] a,int fromindex,int toindex,long val)
          将指定的 long 值分配给指定 long 型数组指定范围中的每个元素。
static voidfill(long[] a,long val)
          将指定的 long 值分配给指定 long 型数组的每个元素。
static voidfill(object[] a,int fromindex,int toindex,object val)
          将指定的 object 引用分配给指定 object 数组指定范围中的每个元素。
static voidfill(object[] a,object val)
          将指定的 object 引用分配给指定 object 数组的每个元素。
static voidfill(short[] a,int fromindex,int toindex,short val)
          将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。
static voidfill(short[] a,short val)
          将指定的 short 值分配给指定 short 型数组的每个元素。
static inthashcode(boolean[] a)
          基于指定数组的内容返回哈希码。
static inthashcode(byte[] a)
          基于指定数组的内容返回哈希码。
static inthashcode(char[] a)
          基于指定数组的内容返回哈希码。
static inthashcode(double[] a)
          基于指定数组的内容返回哈希码。
static inthashcode(float[] a)
          基于指定数组的内容返回哈希码。
static inthashcode(int[] a)
          基于指定数组的内容返回哈希码。
static inthashcode(long[] a)
          基于指定数组的内容返回哈希码。
static inthashcode(object[] a)
          基于指定数组的内容返回哈希码。
static inthashcode(short[] a)
          基于指定数组的内容返回哈希码。
static voidsort(byte[] a)
          对指定的 byte 型数组按数字升序进行排序。
static voidsort(byte[] a,int fromindex,int toindex)
          对指定 byte 型数组的指定范围按数字升序进行排序。
static voidsort(char[] a)
          对指定的 char 型数组按数字升序进行排序。
static voidsort(char[] a,int fromindex,int toindex)
          对指定 char 型数组的指定范围按数字升序进行排序。
static voidsort(double[] a)
          对指定的 double 型数组按数字升序进行排序。
static voidsort(double[] a,int fromindex,int toindex)
          对指定 double 型数组的指定范围按数字升序进行排序。
static voidsort(float[] a)
          对指定的 float 型数组按数字升序进行排序。
static voidsort(float[] a,int fromindex,int toindex)
          对指定 float 型数组的指定范围按数字升序进行排序。
static voidsort(int[] a)
          对指定的 int 型数组按数字升序进行排序。
static voidsort(int[] a,int fromindex,int toindex)
          对指定 int 型数组的指定范围按数字升序进行排序。
static voidsort(long[] a)
          对指定的 long 型数组按数字升序进行排序。
static voidsort(long[] a,int fromindex,int toindex)
          对指定 long 型数组的指定范围按数字升序进行排序。
static voidsort(object[] a)
          根据元素的自然<natural>顺序对指定对象数组按升序进行排序。js随机数
static voidsort(object[] a,int fromindex,int toindex)
          根据元素的自然<natural>顺序对指定对象数组的指定范围按升序进行排序。
static voidsort(short[] a)
          对指定的 short 型数组按数字升序进行排序。
static voidsort(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 stringtostring(boolean[] a)
          返回指定数组内容的字符串表示形式。
static stringtostring(byte[] a)
          返回指定数组内容的字符串表示形式。
static stringtostring(char[] a)
          返回指定数组内容的字符串表示形式。
static stringtostring(double[] a)
          返回指定数组内容的字符串表示形式。
static stringtostring(float[] a)
          返回指定数组内容的字符串表示形式。
static stringtostring(int[] a)
          返回指定数组内容的字符串表示形式。
static stringtostring(long[] a)
          返回指定数组内容的字符串表示形式。
static stringtostring(object[] a)
          返回指定数组内容的字符串表示形式。
static stringtostring(short[] a)
          返回指定数组内容的字符串表示形式。
 
从类 java.lang.object 继承的方法
clone, equals, finalize, getclass, hashcode, notify, notifyall, tostring, wait, wait, wait
 

方法详细校糶ǎn>畔

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)。此算法在许多<xǔ duō>数据集上提供 n*log(n) 性能,这导致其他<other>快速排序会降低二次型性能。

参数:
a - 要排序的数组

sort

public static void sort(long[] a,    int fromindex,    int toindex)
对指定 long 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromindex(包括<included>)一直到索引 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)。此算法在许多<xǔ duō>数据集上提供 n*log(n) 性能,这导致其他快速排序会降低二次型性能。

参数:
a - 要排序的数组
fromindex - 要排序的第一个元素的索引(包括)
toindex - 要排序的最后一个元素的索引(不包括)
抛出:
illegalargumentexception - 如果 fromindex > toindex
arrayindexoutofboundsexception - 如果 fromindex < 0toindex > 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 < 0toindex > 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 < 0toindex > 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 < 0toindex > 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 < 0toindex > a.length

sort

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

虽然 < 关系式对不同数字 -0.0==0.0 返回的结果为 true,并且认为 nan 值既不小于或大于任何浮点值,也不等于任何浮点值,甚至不等于它自身。但 < 关系式不能提供所有<all>浮点值的整体排序。为了允许<yǔn xǔ>进行排序,此方法不使用 < 关系式来确定数字升序排序,而是利用 double.compareto(java.lang.double) 来完成整体排序。此排序法不同于 < 关系式,其中 -0.0 被认为是小于 0.0 的值,并且 nan 被认为大于其他任何浮点值。为了进行排序,所有 nan 值都被认为是等效且相等的。

该排序算法是一个经过调优的快速排序法,改编自 jon l. bentley 和 m. douglas mcilroy 合著的 engineering a sort function", software-practice and experience vol. 23(11) p. 1249-1265 (november 1993)。此算法在许多数据集上提供 n*log(n) 性能,这导致其他快速排序会降低二次型性能。

参数:
a - 要排序的数组

sort

public static void sort(double[] a,    int fromindex,    int toindex)
对指定 double 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromindex(包括)一直到索引 toindex(不包括)。(如果 fromindex==toindex,则排序范围为空。)

虽然 < 关系式对不同数字 -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 < 0toindex > a.length

sort

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

虽然 < 关系式对不同数字 -0.0f==0.0f 返回的结果为 true,并且认为 nan 值既不小于或大于任何浮点值,也不等于任何浮点值,甚至不等于它自身。但 < 关系式不能提供所有浮点值的整体排序。为了允许进行排序,此方法不使用 < 关系式来确定数字升序排序,而是利用 float.compareto(java.lang.float) 来完成整体排序。此排序法不同于 < 关系式,其中 -0.0f 被认为是小于 0.0f 的值,并且 nan 被认为大于其他任何浮点值。为了进行排序,所有 nan 值都被认为是等效且相等的。

该排序算法是一个经过调优的快速排序法,改编自 jon l. bentley 和 m. douglas mcilroy 合著的 engineering a sort function", software-practice and experience vol. 23(11) p. 1249-1265 (november 1993)。此算法在许多数据集上提供 n*log(n) 性能,这导致其他快速排序会降低二次型性能。

参数:
a - 要排序的数组

sort

public static void sort(float[] a,    int fromindex,    int toindex)
对指定 float 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromindex(包括)一直到索引 toindex(不包括)。(如果 fromindex==toindex,则排序范围为空。)

虽然 < 关系式对不同数字 -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 < 0toindex > a.length

sort

public static void sort(object[] a)
根据元素的自然顺序对指定对象数组按升序进行排序。数组中的所有元素都必须实现 comparable 接口。此外,数组中的所有元素都必须是可相互比较的(也就是说,对于数组中的任何 e1e2 元素而言,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 接口。此外,此范围中的所有元素都必须是可相互比较的(也就是说,对于数组中的任何 e1e2 元素而言,e1.compareto(e2) 不得抛出 classcastexception)。

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

该排序算法是一个经过修改的合并排序算法(其中,如果低子列表中的最高元素小于高子列表中的最低元素,则忽略合并)。此算法提供可保证的 n*log(n) 性能。

参数:
a - 要排序的数组
fromindex - 要排序的第一个元素的索引(包括)
toindex - 要排序的最后一个元素的索引(不包括)
抛出:
illegalargumentexception - 如果 fromindex > toindex
arrayindexoutofboundsexception - 如果 fromindex < 0toindex > a.length
classcastexception - 如果数组包含不可相互比较的 的元素(例如,字符串和整数)。

sort

public static <t> void sort(t[] a,      comparator<? super t> c)
根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器可相互比较的(也就是说,对于数组中的任何 e1e2 元素而言,c.compare(e1, e2) 不得抛出 classcastexception)。

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

该排序算法是一个经过修改的合并排序算法(其中,如果低子列表中的最高元素小于高子列表中的最低元素,则忽略合并)。此算法提供可保证的 n*log(n) 性能。

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

sort

public static <t> void sort(t[] a,      int fromindex,      int toindex,      comparator<? super t> c)
根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。排序的范围从索引 fromindex(包括)一直到索引 toindex(不包括)。(如果 fromindex==toindex,则排序范围为空。)此范围内的所有元素都必须是通过指定比较器可相互比较的(也就是说,对于该范围中的任何 e1e2 元素而言,c.compare(e1, e2) 不得抛出 classcastexception)。

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

该排序算法是一个经过修改的合并排序算法(其中,如果低子列表中的最高元素小于高子列表中的最低元素,则忽略合并)。此算法提供可保证的 n*log(n) 性能。

参数:
a - 要排序的数组
fromindex - 要排序的第一个元素的索引(包括)
toindex - 要排序的最后一个元素的索引(不包括)
c - 确定数组顺序的比较器。null 值指示应该使用元素的自然顺序
抛出:
classcastexception - 如果数组包含使用指定的比较器不可相互比较的 的元素。
illegalargumentexception - 如果 fromindex > toindex
arrayindexoutofboundsexception - 如果 fromindex < 0toindex > a.length

binarysearch

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

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

binarysearch

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

参数:
a - 要搜索的数组
fromindex - 要搜索的第一个元素的索引(包括)
toindex - 要搜索的最后一个元素的索引(不包括)
key - 要搜索的值
返回:
如果它包含在数组的指定范围内,则返回搜索键的索引;否则返回 (-(插入点) - 1)插入点 被定义为将键插入数组的那一点:即范围中第一个大于此键的元素索引,如果范围中的所有元素都小于指定的键,则为 toindex。注意,这保证了当且仅当此键被找到时,返回的值将 >=0。
抛出:
illegalargumentexception - 如果 fromindex > toindex
arrayindexoutofboundsexception - 如果 fromindex < 0 或 toindex > a.length
从以下版本开始<appeared>:
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[]) 方法)。如果没有对数组进行排序,则结果是不确定的。(如果数组包含不可相互比较的元素(例如,字符串和整数),则无法 根据其元素的自然顺序对数组进行排序,因此< yīn cǐ>结果是不确定的。)如果数组包含多个等于指定对象的元素,则无法保证找到的是哪一个。

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

binarysearch

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

参数:
a - 要搜索的数组
fromindex - 要搜索的第一个元素的索引(包括)
toindex - 要搜索的最后一个元素的索引(不包括)
key
这样<then>的想法在差异中年男女的族群中特别明显,在45到65岁的受访者中,有32%的单身女子觉得<felt>很快乐,但只有19%的男性这么认为
民进党主席、总统<zǒng tǒng>参选人蔡英文<yīng wén>日前口将参加国庆典<celebration>礼,民进党前行政院长谢长廷认为,这是正确的决定,因为未来可能<kě néng>当总统<zǒng tǒng>的人,未来也要参加嘛!总要有第一次啊!还分什么前后呢!
『人一蓝脑就残』的是这票<ticket>以党国贵族为核心的废物和声音很吵的啦啦队,不是低调跑选区的本土派
新学期新希望<hope>,《CSO 绝对武力》的装备也要跟着翻新,玩家将有高达4倍的转蛋机会<offer>获得
有对象时,假日通常会忙着约会<yuē hui>,重要<important>节日来临,难免会为了另一半花钱、互赠礼物等等,而单身后,时间会突然空出很多,可以< kě yǐ>省钱,买好几件衣服,吃好吃的东西,假日即使宅在家一整天也没关?S,超级惬意!
这位鹦鹉小兄弟<xiōng dì>展现的才艺不是学人说话,而是猛点头啄铃鼓,就向啄木鸟一样,中间累了还会自己<zì jǐ>停下来休息,模样超可爱<love>!网友们看完忍不住笑回,
成家和生孩子在中国<zhōng guó>是非常艰辛的事情<affair>,因结婚年龄<age>逐渐延后,导致生育率下降
国民党立委酝酿总统、立委选举脱钩,柯建铭说,那国民党中央党部的意见<remark>是什么?各党部的意见<remark>又是怎样?最主要<main>还是国民党总统参选人洪秀柱情何以堪,这件事情<affair>看看就好
- 要搜索的值
返回:
如果它包含在数组的指定范围内,则返回搜索键的索引;否则返回 (-(插入点) - 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,则认为它们是相等的。

如果以下条件成立<chéng lì>,则认为两个 double 型数组 d1d2 是相等的:

  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,则认为它们是相等的。

如果以下条件成立<chéng lì>,则认为两个 float 型数组 f1f2 是相等的:

  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)),则认为 e1e2 这两个对象是相等的 。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。此外,如果两个数组引用都为 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 < 0toindex > 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 < 0toindex > 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 < 0toindex > 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 < 0toindex > 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 < 0toindex > 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 < 0toindex > 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 < 0toindex > 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 < 0toindex > 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 < 0toindex > a.length
arraystoreexception - 如果指定值不是可存储在指定数组中的运行时类型

copyof

public static <t> t[] copyof(t[] original,     int newlength)
复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引,这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引,副本将包含 null。当且仅当指定长度大于原数组的长度时,这些索引存在。所得数组和原数组属于完全<wán quán>相同的类。

参数:
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.lengthfrom==to)。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to)(必须大于等于 from)可以大于 original.length,在这种情况下,null 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from

所得数组与原数组属于完全<wán quán>相同的类。

参数:
original - 将要从其复制一个范围的数组
from - 要复制的范围的初始索引(包括)
to - 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
返回:
包含取自原数组指定范围的新数组,截取或用 null 填充以获得所需长度
抛出:
arrayindexoutofboundsexception - 如果 from < 0from > 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.lengthfrom==to)。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to) (必须大于等于 from)可以大于 original.length,在这种情况下,null 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from。所得数组属于 newtype 类。

参数:
original - 将要从其复制一个范围的数组
from - 要复制的范围的初始索引(包括)
to - 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
newtype - 要返回的副本的类
返回:
包含取自原数组指定范围的新数组,截取或用 null 填充以获得所需长度
抛出:
arrayindexoutofboundsexception - 如果 from < 0from > 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.lengthfrom==to)。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to) (必须大于等于 from)可以大于 original.length,在这种情况下,(byte)0 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from

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

copyofrangejs随机数

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

参数:
original - 将要从其复制一个范围的数组
from - 要复制的范围的初始索引(包括)
to - 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
返回:
包含取自原数组指定范围的新数组,截取或用 0 填充以获得所需长度
抛出:
arrayindexoutofboundsexception - 如果 from < 0from > 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.lengthfrom==to)。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to)(必须大于等于 from)可以大于 original.length,在这种情况下,0 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from

参数:
original - 将要从其复制一个范围的数组
from - 要复制的范围的初始索引(包括)
to - 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
返回:
包含取自原数组指定范围的新数组,截取或用 0 填充以获得所需长度
抛出:
arrayindexoutofboundsexception - 如果 from < 0from > 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.lengthfrom==to)。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to)(必须大于等于 from)可以大于 original.length,在这种情况下,>0l 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from

参数:
original - 将要从其复制一个范围的数组
from - 要复制的范围的初始索引(包括)
to - 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
返回:
包含取自原数组指定范围的新数组,截取或用 0 填充以获得所需长度
抛出:
arrayindexoutofboundsexception - 如果 from < 0from > 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.lengthfrom==to)。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to)(必须大于等于 from)可以大于 original.length,在这种情况下,'\\u000' 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from

参数:
original - 将要从其复制一个范围的数组
from - 要复制的范围的初始索引(包括)
to - 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
返回:
包含取自原数组指定范围的新数组,截取或用 0 填充以获得所需长度
抛出:
arrayindexoutofboundsexception - 如果 from < 0from > 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.lengthfrom==to)。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to)(必须大于等于 from)可以大于 original.length,在这种情况下,0f 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from

参数:
original - 将要从其复制一个范围的数组
from - 要复制的范围的初始索引(包括)
to - 要复制的范围的最后索引(不包括)。(此索引可以位于数组范围之外)。
返回:
包含取自原数组指定范围的新数组,截取或用 0 填充以获得所需长度
抛出:
arrayindexoutofboundsexception - 如果 from < 0from > 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.lengthfrom==to)。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to)(必须大于等于 from)可以大于 original.length,在这种情况下,0d 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from

参数:
original - 将要从其复制一个范围的数组
from - 要复制的范围的初始索引(包括)
to - 要复制的范围的最后索引(不包括)。(此索引可能<kě néng>位于数组范围之外)。
返回:
包含取自原数组指定范围的新数组,截取或用 0 填充以获得所需长度
抛出:
arrayindexoutofboundsexception - 如果 from < 0from > 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.lengthfrom==to)。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to) (必须大于等于 from)可以大于 original.length,在这种情况下,false 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from

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

aslist

public static <t> list<t> aslist(t... a)
返回一个受指定数组支持<support>的固定大小的列表。(对返回列表的更改会“直接写”到数组。)此方法同 collection.toarray() 一起<yī qǐ>,充当了基于数组的 api 与基于 collection 的 api 之间的桥梁。返回的列表是可序列化的,并且实现了 randomaccess

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

 list<string> stooges=arrays.aslist("larry", "moe", "curly"); 

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

hashcode

public static int hashcode(long[] a)
基于指定数组的内容返回哈希码。对于任何两个满足<mǎn zú> arrays.equals(a, b)long 型数组 ab,也可以说 arrays.hashcode(a)==arrays.hashcode(b)

此方法返回的值与在 list 上调用 hashcode 方法获得的值相同,该 list 包含以相同顺序表示 a 数组元素的 long 实例的序列。如果 anull,则此方法返回 0。

参数:
a - 要计算其哈希值的数组
返回:
a 数组基于内容的哈希码
从以下版本开始:
1.5

hashcode

public static int hashcode(int[] a)
基于指定数组的内容返回哈希码。对于任何两个满足<mǎn zú> arrays.equals(a, b) 的非 null int 型数组 ab,也可以说 arrays.hashcode(a)==arrays.hashcode(b)

此方法返回的值与在 list 上调用 hashcode 方法获得的值相同,该 list 包含以相同顺序表示 a 数组元素的 integer 实例的序列。如果 anull,则此方法返回 0。

参数:
a - 要计算其哈希值的数组
返回:
a 数组基于内容的哈希码
从以下版本开始:
1.5

hashcode

public static int hashcode(short[] a)
基于指定数组的内容返回哈希码。对于任何两个满足 arrays.equals(a, b)short 型数组 ab,也可用说 arrays.hashcode(a)==arrays.hashcode(b)

此方法返回的值与在 list 上调用 hashcode 方法获得的值相同,该 list 包含以相同顺序表示 a 数组元素的 short 实例的序列。如果 anull,则此方法返回 0。

参数:
a - 要计算其哈希值的数组
返回:
a 数组基于内容的哈希码
从以下版本开始:
1.5

hashcode

public static int hashcode(char[] a)
基于指定数组的内容返回哈希码。对于任何两个满足 arrays.equals(a, b)char 型数组 ab,也可用说 arrays.hashcode(a)==arrays.hashcode(b)

此方法返回的值与在 list 上调用 hashcode 方法获得的值相同,该 list 包含以相同顺序表示 a 数组元素的 character 实例的序列。如果 anull,则此方法返回 0。

参数:
a - 要计算其哈希值的数组
返回:
a 数组基于内容的哈希码
从以下版本开始:
1.5

hashcode

public static int hashcode(byte[] a)
基于指定数组的内容返回哈希码。对于任何两个满足 arrays.equals(a, b)byte 型数组 ab,也可用说 arrays.hashcode(a)==arrays.hashcode(b)

此方法返回的值与在 list 上调用 hashcode 方法获得的值相同,该 list 包含以相同顺序表示 a 数组元素的 byte 实例的序列。如果 anull,则此方法返回 0。

参数:
a - 要计算其哈希值的数组
返回:
a 数组基于内容的哈希码
从以下版本开始:
1.5

hashcode

public static int hashcode(boolean[] a)
基于指定数组的内容返回哈希码。对于任何两个满足 arrays.equals(a, b)boolean 型数组 ab,也可以说 arrays.hashcode(a)==arrays.hashcode(b)

此方法返回的值与在 list 上调用 hashcode 方法获得的值相同,该 list 包含以相同顺序表示 a 数组元素的 boolean 实例的序列。如果 anull,则此方法返回 0。

参数:
a - 要计算其哈希值的数组
返回:
a 数组基于内容的哈希码
从以下版本开始:
1.5

hashcode

public static int hashcode(float[] a)
基于指定数组的内容返回哈希码。对于任何两个满足 arrays.equals(a, b)float 型数组 ab,也可以说 arrays.hashcode(a)==arrays.hashcode(b)

此方法返回的值与在 list 上调用 hashcode 方法获得的值相同,该 list 包含以相同顺序表示 a 数组元素的 float 实例的序列。如果 anull,则此方法返回 0。

参数:
a - 要计算其哈希值的数组
返回:
a 数组基于内容的哈希码
从以下版本开始:
1.5

hashcode

public static int hashcode(double[] a)
基于指定数组的内容返回哈希码。对于任何两个满足 arrays.equals(a, b)double 型数组 ab,也可以说 arrays.hashcode(a)==arrays.hashcode(b)

此方法返回的值与在 list 上调用 hashcode 方法获得的值相同,该 list 包含以相同顺序表示 a 数组元素的 double 实例的序列。如果 anull,则此方法返回 0。

参数:
a - 要计算其哈希值的数组
返回:
a 数组基于内容的哈希码
从以下版本开始:
1.5

hashcode

public static int hashcode(object[] a)
基于指定数组的内容返回哈希码。如果数组包含作为元素的其他数组,则哈希码将基于其标识,而不是基于其内容。所以,在将自身包含为一个元素的数组上,直接或间接通过一个或多个数组级别来调用此方法是可接受<accepted>的。

对于任何两个满足 arrays.equals(a, b) 的数组 ab,也可以说 arrays.hashcode(a)==arrays.hashcode(b)

此方法返回的值等于 arrays.aslist(a).hashcode() 返回的值,除非 anull,在这种情况下返回 0

参数:
a - 将计算其基于内容的哈希码的数组
返回:
a 数组基于内容的哈希码
从以下版本开始:
1.5
另请参见:
deephashcode(object[])

deephashcode

public static int deephashcode(object[] a)
基于指定数组的“深层内容”返回哈希码。如果数组包含作为元素的其他数组,则哈希码将基于其内容,并以此类推,直至无穷。所以,在将自身包含为一个元素的数组上,直接或间接通过一个或多个数组级别来调用此方法是不可接受<accepted>的。这种调用的行为是不确定的。

对于任何两个满足 arrays.deepequals(a, b) 的数组 ab,也可以说 arrays.deephashcode(a)==arrays.deephashcode(b)

对此方法返回值的计算类似于对列表上的 list.hashcode() 返回值的计算,该列表以相同的顺序包含与 a 数组相同的元素,但有一点不同:如果数组 ae 元素本身是一个数组,则不能通过调用 e.hashcode() 计算其哈希码,但是<But>,如果 e 是一个基本类型数组,则可以通过调用 arrays.hashcode(e) 的适当重载来计算其哈希码,或者,如果 e 是一个引用类型数组,则可以通过递归调用 arrays.deephashcode(e) 来计算其哈希码。如果 anull,则此方法返回 0。

参数:
a - 将计算其基于深层内容的哈希码的数组
返回:
a 数组基于深层内容的哈希码
从以下版本开始:
1.5
另请参见:
hashcode(object[])

deepequals

public static boolean deepequals(object[] a1,       object[] a2)
如果两个指定数组彼此是深层相等 的,则返回 true。与 equals(object[],object[]) 方法不同,此方法适用于任意深度的嵌套数组。

如果两个数组引用均为 null,或者它们引用了包含相同元素数量的数组,并且两个数组中的所有相应元素对都是深层相等的,则认为这两个数组引用是深层相等的。

如果满足以下任意条件之一,则两个 null 元素 e1e2 可能是深层相等的:

注意,此定义支持任意深度的 null 元素。

如果指定数组中的任意一个数组,直接或间接通过一个或多个数组级别,包含数组本身作为其元素,则此方法的行为是不确定的。

参数:
a1 - 将测试其相等性的一个数组
a2 - 将测试其相等性的另一个数组
返回:
如果两个数组相等,则返回 true
从以下版本开始:
1.5
另请参见:
equals(object[],object[])

tostring

public static string tostring(long[] a)
返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成,括在方括号("[]")中。相邻元素用字符 ", "(逗号加空格)分隔。这些元素通过 string.valueof(long) 转换为字符串。如果 anull,则返回 "null"

参数:
a - 返回其字符串表示形式的数组
返回:
a 的字符串表示形式
从以下版本开始:
1.5

tostring

public static string tostring(int[] a)
返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成,括在方括号("[]")中。相邻元素用字符 ", "(逗号加空格)分隔。这些元素通过 string.valueof(int) 转换为字符串。如果 anull,则返回 "null"

参数:
a - 返回其字符串表示形式的数组
返回:
a 的字符串表示形式
从以下版本开始:
1.5

tostring

public static string tostring(short[] a)
返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成,括在方括号("[]")中。相邻元素用字符 ", "(逗号加空格)分隔。这些元素通过 string.valueof(short) 转换为字符串。如果 anull,则返回 "null"

参数:
a - 返回其字符串表示形式的数组
返回:
a 的字符串表示形式
从以下版本开始:
1.5

tostring

public static string tostring(char[] a)
返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成,括在方括号("[]")中。相邻元素用字符 ", "(逗号加空格)分隔。这些元素通过 string.valueof(char) 转换为字符串。如果 anull,则返回 "null"

参数:
a - 返回其字符串表示形式的数组
返回:
a 的字符串表示形式
从以下版本开始:
1.5

tostring

public static string tostring(byte[] a)
返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成,括在方括号("[]")中。相邻元素用字符 ", "(逗号加空格)分隔。这些元素通过 string.valueof(byte) 转换为字符串。如果 anull,则返回 "null"

参数:
a - 返回其字符串表示形式的数组
返回:
a 的字符串表示形式
从以下版本开始:
1.5

tostring

public static string tostring(boolean[] a)
返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成,括在方括号("[]")中。相邻元素用字符 ", "(逗号加空格)分隔。这些元素通过 string.valueof(boolean) 转换为字符串。如果 anull,则返回 "null"

参数:
a - 返回其字符串表示形式的数组
返回:
a 的字符串表示形式
从以下版本开始:
1.5

tostring

public static string tostring(float[] a)
返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成,括在方括号("[]")中。相邻元素用字符 ", "(逗号加空格)分隔。这些元素通过 string.valueof(float) 转换为字符串。如果 anull,则返回 "null"

参数:
a - 返回其字符串表示形式的数组
返回:
a 的字符串表示形式
从以下版本开始:
1.5

tostring

public static string tostring(double[] a)
返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成,括在方括号("[]")中。相邻元素用字符 ", "(逗号加空格)分隔。这些元素通过 string.valueof(double) 转换为字符串。如果 anull,则返回 "null"

参数:
a - 返回其字符串表示形式的数组
返回:
a 的字符串表示形式
从以下版本开始:
1.5

tostring

public static string tostring(object[] a)
返回指定数组内容的字符串表示形式。如果数组包含作为元素的其他数组,则通过从 object 中继承的 object.tostring() 方法将它们转换为字符串,这描述了它们的标识,而不是它们的内容。

此方法返回的值等于 arrays.aslist(a).tostring() 返回的值,除非 anull,在这种情况下返回 "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[])

javatm platform
standard ed. 6

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

版权所有 2007 sun microsystems, inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策