Java Arrays 类

2025年4月28日 | 20分钟阅读

Java 中,Arrays 类是一个实用类,它是 Java 集合框架 的成员。它属于 java.util 包。该类提供了各种静态方法,用于高效地操作数组。它简化了数组上的常见操作(如搜索、排序、复制和比较)。

阅读更多 Java 数组

为什么使用 Java Arrays 类?

使用 Java Arrays 类的主要原因在于它提供了现成的、用于复杂逻辑的方法。以下是开发人员经常使用它的原因。

  1. 便捷性:Arrays 类对于数组操作非常方便,因为它提供了各种现成的静态方法来执行复杂的逻辑。它消除了为数组操作编写复杂代码的需要。
  2. 效率:此类中的方法提供了高度优化的算法(原始类型使用双枢轴快速排序,对象使用 TimSort)。它提供了更好的性能,从而提高了效率。
  3. 可读性:Arrays 类的方法遵循直观的名称(易于发音、拼写和理解的名称,通常具有直接且熟悉的声音)和行为,使代码更易于阅读、理解和维护。
  4. 简化代码:通过使用 Arrays 类,代码变得更清洁、更简洁。我们可以使用 Arrays.toString() 方法将数组转换为字符串,而无需编写循环。
  5. 增强的功能:该类提供了高级功能,如使用 Arrays.deepEquals() 方法进行深度比较、使用 Arrays.fill() 方法高效填充数组以及使用 Arrays.stream() 方法处理流。
  6. 集合兼容性:该类允许将数组无缝转换为列表,从而更轻松地使用集合框架。

Java Arrays 类的方法

操纵方法签名描述
排序sort(byte[] a)

 

 

将指定数组按升序数值顺序排序。
sort(byte[] a, int fromIndex, int toIndex)将指定范围的数组按升序排序。
sort(char[] a)

 

 

将指定数组按升序数值顺序排序。
sort(char[] a, int fromIndex, int toIndex)将指定范围的数组按升序排序。
sort(double[] a)将指定数组按升序数值顺序排序。
sort(double[] a, int fromIndex, int toIndex)
将指定范围的数组按升序排序。
sort(float[] a)将指定数组按升序数值顺序排序。
sort(float[] a, int fromIndex, int toIndex)将指定范围的数组按升序排序。
sort(int[] a)将指定数组按升序数值顺序排序。
sort(int[] a, int fromIndex, int toIndex)将指定范围的数组按升序排序。
sort(long[] a)将指定数组按升序数值顺序排序。
sort(long[] a, int fromIndex, int toIndex)将指定范围的数组按升序排序。
sort(short[] a)将指定数组按升序数值顺序排序。
sort(short[] a, int fromIndex, int toIndex)将指定范围的数组按升序排序。
sort(Object[] a)

 

 

根据其元素的自然顺序,将指定对象数组按升序排序。
sort(Object[] a, int fromIndex, int toIndex)

 

 

根据其元素的自然顺序,将指定数组的指定范围按升序排序。
sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)根据指定比较器的顺序,对指定数组的指定范围进行排序。
sort(T[] a, Comparator<? super T> c)

 

 

根据指定比较器的顺序,对指定对象数组进行排序。
搜索binarySearch(byte[] a, byte key)使用二分搜索算法搜索指定字节数组中的指定值。
binarySearch(byte[] a, int fromIndex, int toIndex, byte key)使用二分搜索算法搜索指定字节数组的指定范围中的指定值。
binarySearch(char[] a, char key)使用二分搜索算法搜索指定字符数组中的指定值。
binarySearch(char[] a, int fromIndex, int toIndex, char key)使用二分搜索算法搜索指定字符数组的指定范围中的指定值。
binarySearch(double[] a, double key)使用二分搜索算法搜索指定双精度数组中的指定值。
binarySearch(double[] a, int fromIndex, int toIndex, double key)使用二分搜索算法搜索指定双精度数组的指定范围中的指定值。
binarySearch(float[] a, float key)

 

 

使用二分搜索算法搜索指定浮点数数组中的指定值。
binarySearch(float[] a, int fromIndex, int toIndex, float key)使用二分搜索算法搜索指定浮点数数组的指定范围中的指定值。
binarySearch(int[] a, int key)使用二分搜索算法搜索指定整数数组中的指定值。
binarySearch(int[] a, int fromIndex, int toIndex, int key)使用二分搜索算法搜索指定整数数组的指定范围中的指定值。
binarySearch(long[] a, int fromIndex, int toIndex, long key)使用二分搜索算法搜索指定长整型数组的指定范围中的指定值。
binarySearch(long[] a, long key)

 

 

使用二分搜索算法搜索指定长整型数组中的指定值。
binarySearch(short[] a, int fromIndex, int toIndex, short key)

 

 

使用二分搜索算法搜索指定短整型数组的指定范围中的指定值。
binarySearch(short[] a, short key)

 

 

使用二分搜索算法搜索指定短整型数组中的指定值。
binarySearch(Object[] a, int fromIndex, int toIndex, Object key)

 

 

使用二分搜索算法搜索指定数组的指定范围中的指定对象。
binarySearch(Object[] a, Object key)

 

 

使用二分搜索算法搜索指定数组中的指定对象。
binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)使用二分搜索算法搜索指定数组的指定范围中的指定对象。
binarySearch(T[] a, T key, Comparator<? super T> c)使用二分搜索算法搜索指定数组中的指定对象。
比较deepEquals(Object[] a1, Object[] a2)当两个指定数组深度相等时返回 true。
deepHashCode(Object[] a)

 

 

返回基于指定数组“深度内容”的哈希码。
deepToString(Object[] a)返回指定数组“深度内容”的字符串表示形式。
equals(boolean[] a, boolean[] a2)

 

 


当两个指定的布尔数组相等时返回 true。
equals(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)当两个指定的布尔数组在指定范围内相等时返回 true。
equals(byte[] a, byte[] a2)当两个指定的字节数组相等时返回 true。
equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)当两个指定的字节数组在指定范围内相等时返回 true。
equals(char[] a, char[] a2)当两个指定的字符数组相等时返回 true。
equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)当两个指定的字符数组在指定范围内相等时返回 true。
equals(double[] a, double[] a2)当两个指定的双精度数组相等时返回 true。
equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)当两个指定的双精度数组在指定范围内相等时返回 true。
equals(float[] a, float[] a2)当两个指定的浮点数数组相等时返回 true。
equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)当两个指定的浮点数数组在指定范围内相等时返回 true。
equals(int[] a, int[] a2)当两个指定的整数数组相等时返回 true。
equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)当两个指定的整数数组在指定范围内相等时返回 true。
equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)当两个指定的长整型数组在指定范围内相等时返回 true。
equals(long[] a, long[] a2)当两个指定的长整型数组相等时返回 true。
equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)当两个指定的短整型数组在指定范围内相等时返回 true。

equals(short[] a, short[] a2)

 

 

当两个指定的短整型数组相等时返回 true。
equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)当两个指定的对象数组在指定范围内相等时返回 true。

equals(Object[] a, Object[] a2)

 

 

当两个指定的对象数组相等时返回 true。
equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)当两个指定的对象数组在指定范围内相等时返回 true。
equals(T[] a, T[] a2, Comparator<? super T> cmp)当两个指定的对象数组相等时返回 true。
compare(boolean[] a, boolean[] b)按字典序比较两个布尔数组。
compare(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个布尔数组。
compare(byte[] a, byte[] b)按字典序比较两个字节数组。
compare(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个字节数组。
compare(char[] a, char[] b)按字典序比较两个字符数组。
compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个字符数组。
compare(double[] a, double[] b)按字典序比较两个双精度数组。
compare(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个双精度数组。
compare(float[] a, float[] b)按字典序比较两个浮点数数组。
compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个浮点数数组。
compare(int[] a, int[] b)按字典序比较两个整数数组。
compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个整数数组。
compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个长整型数组。
compare(long[] a, long[] b)按字典序比较两个长整型数组。
compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个短整型数组。
compare(short[] a, short[] b)按字典序比较两个短整型数组。
compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个对象数组。
compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)在指定范围内按字典序比较两个对象数组。
compare(T[] a, T[] b)按字典序比较两个对象数组(在可比较的元素之间)。
compare(T[] a, T[] b, Comparator<? super T> cmp)使用指定的比较器按字典序比较两个对象数组。
compareUnsigned(byte[] a, byte[] b)按字典序比较两个字节数组,将元素视为无符号。
compareUnsigned(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个字节数组,将元素视为无符号。
compareUnsigned(int[] a, int[] b)按字典序比较两个整数数组,将元素视为无符号。
compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个整数数组,将元素视为无符号。
compareUnsigned(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个长整型数组,将元素视为无符号。
compareUnsigned(long[] a, long[] b)按字典序比较两个长整型数组,将元素视为无符号。
compareUnsigned(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)在指定范围内按字典序比较两个短整型数组,将元素视为无符号。
compareUnsigned(short[] a, short[] b)按字典序比较两个短整型数组,将元素视为无符号。
复印copyOf(boolean[] original, int newLength)复制指定的数组,截断或用 false 填充(如果需要),以便副本具有指定的长度。
copyOf(byte[] original, int newLength)复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。
copyOf(char[] original, int newLength)复制指定的数组,截断或用空字符填充(如果需要),以便副本具有指定的长度。
copyOf(double[] original, int newLength)复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。
copyOf(float[] original, int newLength)复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。
copyOf(int[] original, int newLength)复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。
copyOf(long[] original, int newLength)复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。
copyOf(short[] original, int newLength)复制指定的数组,截断或用零填充(如果需要),以便副本具有指定的长度。
copyOf(T[] original, int newLength)复制指定的数组,截断或用 null 填充(如果需要),以便副本具有指定的长度。
copyOf(U[] original, int newLength, Class<? extends T[]> newType)复制指定的数组,截断或用 null 填充(如果需要),以便副本具有指定的长度。
copyOfRange(boolean[] original, int from, int to)将指定数组的指定范围复制到一个新数组中。
copyOfRange(byte[] original, int from, int to)将指定数组的指定范围复制到一个新数组中。
copyOfRange(char[] original, int from, int to)将指定数组的指定范围复制到一个新数组中。
copyOfRange(double[] original, int from, int to)将指定数组的指定范围复制到一个新数组中。
copyOfRange(float[] original, int from, int to)将指定数组的指定范围复制到一个新数组中。
copyOfRange(int[] original, int from, int to)将指定数组的指定范围复制到一个新数组中。
copyOfRange(long[] original, int from, int to)将指定数组的指定范围复制到一个新数组中。
copyOfRange(short[] original, int from, int to)将指定数组的指定范围复制到一个新数组中。
copyOfRange(T[] original, int from, int to)将指定数组的指定范围复制到一个新数组中。
copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)将指定数组的指定范围复制到一个新数组中。
填充fill(boolean[] a, boolean val)将指定的布尔值分配给指定布尔数组的每个元素。
fill(boolean[] a, int fromIndex, int toIndex, boolean val)将指定的布尔值分配给指定布尔数组的指定范围的每个元素。
fill(byte[] a, byte val)将指定的字节值分配给指定字节数组的每个元素。
fill(byte[] a, int fromIndex, int toIndex, byte val)将指定的字节值分配给指定字节数组的指定范围的每个元素。
fill(char[] a, char val)将指定的字符值分配给指定字符数组的每个元素。
fill(char[] a, int fromIndex, int toIndex, char val)将指定的字符值分配给指定字符数组的指定范围的每个元素。
fill(double[] a, double val)将指定的双精度值分配给指定双精度数组的每个元素。
fill(double[] a, int fromIndex, int toIndex, double val)将指定的双精度值分配给指定双精度数组的指定范围的每个元素。
fill(float[] a, float val)将指定的浮点数值分配给指定浮点数数组的每个元素。
fill(float[] a, int fromIndex, int toIndex, float val)将指定的浮点数值分配给指定浮点数数组的指定范围的每个元素。
fill(int[] a, int val)将指定的整数值分配给指定整数数组的每个元素。
fill(int[] a, int fromIndex, int toIndex, int val)将指定的整数值分配给指定整数数组的指定范围的每个元素。
fill(long[] a, int fromIndex, int toIndex, long val)将指定的长整型值分配给指定长整型数组的指定范围的每个元素。
fill(long[] a, long val)将指定的长整型值分配给指定长整型数组的每个元素。
fill(short[] a, int fromIndex, int toIndex, short val)将指定的短整型值分配给指定短整型数组的指定范围的每个元素。
fill(short[] a, short val)将指定的短整型值分配给指定短整型数组的每个元素。
fill(Object[] a, int fromIndex, int toIndex, Object val)将指定的 Object 引用分配给指定对象数组的指定范围的每个元素。
fill(Object[] a, Object val)将指定的 Object 引用分配给指定对象数组的每个元素。
Streamstream(double[] array)返回一个以指定数组为源的顺序 DoubleStream。
stream(double[] array, int startInclusive, int endExclusive)返回一个以指定数组的指定范围为源的顺序 DoubleStream。
stream(int[] array)返回一个以指定数组为源的顺序 IntStream。
stream(int[] array, int startInclusive, int endExclusive)返回一个以指定数组的指定范围为源的顺序 IntStream。
stream(long[] array)返回一个以指定数组为源的顺序 LongStream。
stream(long[] array, int startInclusive, int endExclusive)返回一个以指定数组的指定范围为源的顺序 LongStream。
stream(T[] array)

 

 

返回一个以指定数组为源的顺序 Stream。
stream(T[] array, int startInclusive, int endExclusive)返回一个以指定数组的指定范围为源的顺序 Stream。
转换toString(boolean[] a)返回指定数组内容的字符串表示形式。
toString(byte[] a)返回指定数组内容的字符串表示形式。
toString(char[] a)返回指定数组内容的字符串表示形式。
toString(double[] a)返回指定数组内容的字符串表示形式。
toString(float[] a)返回指定数组内容的字符串表示形式。
toString(int[] a)返回指定数组内容的字符串表示形式。
toString(long[] a)

 

 

返回指定数组内容的字符串表示形式。
toString(short[] a)

 

 

返回指定数组内容的字符串表示形式。
toString(Object[] a)返回指定数组内容的字符串表示形式。
 asList(T... a)返回一个由指定数组支持的固定大小的列表。
用途hashCode(boolean[] a)返回基于指定数组内容的哈希码。
hashCode(byte[] a)返回基于指定数组内容的哈希码。
hashCode(char[] a)返回基于指定数组内容的哈希码。
hashCode(double[] a)返回基于指定数组内容的哈希码。
hashCode(float[] a)返回基于指定数组内容的哈希码。
hashCode(int[] a)返回基于指定数组内容的哈希码。
hashCode(long[] a)返回基于指定数组内容的哈希码。
hashCode(short[] a)返回基于指定数组内容的哈希码。
hashCode(Object[] a)返回基于指定数组内容的哈希码。
mismatch(boolean[] a, boolean[] b)查找并返回两个布尔数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)在指定范围内查找并返回两个布尔数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。
mismatch(byte[] a, byte[] b)查找并返回两个字节数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)在指定范围内查找并返回两个字节数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。
mismatch(char[] a, char[] b)查找并返回两个字符数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)在指定范围内查找并返回两个字符数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。
mismatch(double[] a, double[] b)查找并返回两个双精度数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)在指定范围内查找并返回两个双精度数组之间第一个不匹配项的相对索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(float[] a, float[] b)查找并返回两个浮点数数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)在指定范围内查找并返回两个浮点数数组之间第一个不匹配项的相对索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(int[] a, int[] b)查找并返回两个整数数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)在指定范围内查找并返回两个整数数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。
mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)在指定范围内查找并返回两个长整型数组之间第一个不匹配项的相对索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(long[] a, long[] b)查找并返回两个长整型数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)在指定范围内查找并返回两个短整型数组之间第一个不匹配项的相对索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(short[] a, short[] b)查找并返回两个短整型数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)在指定范围内查找并返回两个对象数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。
mismatch(Object[] a, Object[] b)查找并返回两个对象数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。
mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)在指定范围内查找并返回两个对象数组之间第一个不匹配项的相对索引,否则如果没有找到不匹配项,则返回 -1。
mismatch(T[] a, T[] b, Comparator<? super T> cmp)查找并返回两个对象数组之间第一个不匹配项的索引;否则,如果没有找到不匹配项,则返回 -1。
并行数组parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)对给定数组的子范围执行 parallelPrefix(double[], DoubleBinaryOperator)。
parallelPrefix(double[] array, DoubleBinaryOperator op)使用提供的函数,并行地累加给定数组的每个元素(就地)。
parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)对给定数组的子范围执行 parallelPrefix(int[], IntBinaryOperator)。
parallelPrefix(int[] array, IntBinaryOperator op)使用提供的函数,并行地累加给定数组的每个元素(就地)。
parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)对给定数组的子范围执行 parallelPrefix(long[], LongBinaryOperator)。
parallelPrefix(long[] array, LongBinaryOperator op)使用提供的函数,并行地累加给定数组的每个元素(就地)。
parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)对给定数组的子范围执行 parallelPrefix(Object[], BinaryOperator)。
parallelPrefix(T[] array, BinaryOperator<T> op)使用提供的函数,并行地累加给定数组的每个元素(就地)。
parallelSetAll(double[] array, IntToDoubleFunction generator)使用提供的生成器函数计算每个元素,并行设置指定数组的所有元素。
parallelSetAll(int[] array, IntUnaryOperator generator)使用提供的生成器函数计算每个元素,并行设置指定数组的所有元素。
parallelSetAll(long[] array, IntToLongFunction generator)使用提供的生成器函数计算每个元素,并行设置指定数组的所有元素。
parallelSetAll(T[] array, IntFunction<? extends T> generator)使用提供的生成器函数计算每个元素,并行设置指定数组的所有元素。
parallelSort(byte[] a)将指定数组按升序数值顺序排序。
parallelSort(byte[] a, int fromIndex, int toIndex)将指定范围的数组按升序数值顺序排序。
parallelSort(char[] a)将指定数组按升序数值顺序排序。
parallelSort(char[] a, int fromIndex, int toIndex)将指定范围的数组按升序数值顺序排序。
parallelSort(double[] a)将指定数组按升序数值顺序排序。
parallelSort(double[] a, int fromIndex, int toIndex)将指定范围的数组按升序数值顺序排序。
parallelSort(float[] a)将指定数组按升序数值顺序排序。
parallelSort(float[] a, int fromIndex, int toIndex)将指定范围的数组按升序数值顺序排序。
parallelSort(int[] a)将指定数组按升序数值顺序排序。
parallelSort(int[] a, int fromIndex, int toIndex)将指定范围的数组按升序数值顺序排序。
parallelSort(long[] a)将指定数组按升序数值顺序排序。
parallelSort(long[] a, int fromIndex, int toIndex)将指定范围的数组按升序数值顺序排序。
parallelSort(short[] a)将指定数组按升序数值顺序排序。
parallelSort(short[] a, int fromIndex, int toIndex)将指定范围的数组按升序数值顺序排序。
parallelSort(T[] a)根据其元素的自然顺序,将指定对象数组按升序排序。
parallelSort(T[] a, int fromIndex, int toIndex)根据其元素的自然顺序,将指定数组的指定范围按升序排序。
parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)根据指定比较器的顺序,对指定数组的指定范围进行排序。
parallelSort(T[] a, Comparator<? super T> cmp)根据指定比较器的顺序,对指定对象数组进行排序。
SetsetAll(double[] array, IntToDoubleFunction generator)使用提供的生成器函数计算每个元素,设置指定数组的所有元素。
setAll(int[] array, IntUnaryOperator generator)使用提供的生成器函数计算每个元素,设置指定数组的所有元素。
setAll(long[] array, IntToLongFunction generator)使用提供的生成器函数计算每个元素,设置指定数组的所有元素。
setAll(T[] array, IntFunction<? extends T> generator)使用提供的生成器函数计算每个元素,设置指定数组的所有元素。

Arrays 类方法示例

让我们看一些 Java Arrays 类常用的方法。

1. 使用 sort() 方法对数组进行排序

示例

编译并运行

输出

Sorted Array: [1, 2, 3, 5, 8]

当按降序排序时,对 Integer[] 数组应用 Arrays.sort() 和 Collections.reverseOrder() 处理。

2. 使用 equals() 方法比较两个数组

示例

编译并运行

输出

true

3. 使用 binarySearch() 方法搜索数组

示例

编译并运行

输出

Index of 5 is: 2

注意:在使用 binarySearch() 方法之前,必须对数组进行排序;否则,结果将不可预测。

4. 使用 fill() 方法填充数组

示例

输出

Filled Array: [10, 10, 10, 10, 10]

5. 使用 copyOf() 方法复制数组

示例

编译并运行

输出

Copied Array: [1, 2, 3]

6. 使用 toString() 方法转换数组

示例

输出

Array as String: [Alice, Bob, Charlie]

7. 使用 deepEquals() 方法比较二维数组

示例

编译并运行

输出

Are the given arrays equal to each other?
true
[[4, 8, 0], [9, 5, 1], [7, 2, 6]]