极客教程Java中的Arrays类
Arrays 类位于 java.util包 中，是 Java Collection Framework 的一部分。此类提供静态方法来动态创建和访问 Java数组 。它只包含静态方法和Object类的方法。此类的方法可以通过类名本身使用。
类层次结构如下所示：
java.lang.Object
↳ java.util.Arrays
Geek，现在您一定会想知道既然我们能够声明、初始化和执行有关数组的操作，为什么我们需要java Arrays类。虽然答案在于此类的方法，我们将进一步讨论这些方法，因为实际上这些函数有助于程序员拓展数组的范围，比如经常会使用 循环 在数组上执行一些任务，例如：
- 使用特定值填充数组。
- 对Arrays进行排序。
- 在Arrays中搜索。
- 等等。
在此，Arrays类提供了几个静态方法，可以直接使用这些方法来执行这些任务，而无需使用循环，因此使我们的代码更加简短和优化。
语法： 类声明
public class Arrays
extends Object
语法： 使用Arrays
Arrays.<function name>;
Java数组类中的方法
java.util包的Arrays类包含几个静态方法，可用于填充、排序、搜索等数组。现在让我们以表格格式讨论此类的一些方法，如下所示：
| 方法 | 执行的操作 |
|---|---|
| asList() | 返回一个由指定数组支持的固定大小列表。 |
| binarySearch() | 使用二分查找算法在数组中查找指定的元素。 |
| binarySearch(array, fromIndex, toIndex, key, Comparator) | 使用二分查找算法搜索指定数组的一定范围内的指定对象。 |
| compare(array 1, array 2) | 按字典顺序比较两个作为参数传递的数组。 |
| copyOf(originalArray, newLength) | 复制指定的数组，并截断或填充默认值（如果需要），使得副本具有指定的长度。 |
| copyOfRange(originalArray, fromIndex, endIndex) | 将指定数组的指定范围复制到一个新的数组中。 |
| deepEquals(Object[] a1, Object[] a2) | 如果两个指定的数组彼此深度相等，则返回true。 |
| deepHashCode(Object[] a) | 基于指定数组的“深度内容”返回哈希码。 |
| deepToString(Object[] a) | 返回指定数组的“深度内容”的字符串表示形式。 |
| equals(array1, array2) | 检查两个数组是否相等。 |
| fill(originalArray, fillValue) | 将此填充值分配给此数组的每个索引。 |
| hashCode(originalArray) | 返回此数组实例的整数哈希码。 |
| mismatch(array1, array2) | 查找并返回两个指定数组之间第一个不匹配元素的索引。 |
| parallelPrefix(originalArray, fromIndex, endIndex, functionalOperator) | 使用指定的函数运算符对数组的给定范围执行parallelPrefix。 |
| parallelPrefix(originalArray, operator) | 使用指定的函数运算符执行完整数组的parallelPrefix。 |
| parallelSetAll(originalArray, functionalGenerator) | 使用提供的生成器函数并行设置此数组的所有元素。 |
| parallelSort(originalArray) | 使用并行排序对指定的数组进行排序。 |
| setAll(originalArray, functionalGenerator) | 使用提供的生成器函数设置指定数组的所有元素。 |
| sort(originalArray) | 将整个数组按升序排序。 |
| sort(originalArray, fromIndex, endIndex) | 将指定范围的数组按升序排序。 |
| sort(T[] a, int fromIndex, int toIndex, Comparator< super T> c) | 根据指定比较器引起的顺序，对指定数组对象的指定范围进行排序。 | sort(T[] a, Comparator< super T> c) | 根据指定比较器引起的顺序，对指定的对象数组进行排序。 |
| spliterator(originalArray) | 返回一个涵盖指定数组所有元素的Spliterator。 |
| spliterator(originalArray, fromIndex, endIndex) | 返回一个Spliterator，它涵盖指定数组的一定范围。 |
实现：
示例 1： asList() 方法
// Java程序演示Arrays类
// 通过asList()方法
// 导入java.util包中的Arrays工具类
import java.util.Arrays;
// 主类
class GFG {
// 主驱动程序
public static void main(String[] args)
{
// 获取数组
int intArr[] = { 10, 20, 15, 22, 35 };
// 将元素转换为列表
System.out.println("整数数组转为列表: "
+ Arrays.asList(intArr));
}
}
输出
整数数组转为列表: [[I@2f4d3709]
示例 2： binarySearch() 方法
该方法使用二分查找算法在数组中搜索指定的元素。
// Java程序演示Arrays类
// 通过binarySearch()方法
// 导入java.util包中的Arrays工具类
import java.util.Arrays;
// 主类
public class GFG {
// 主驱动程序
public static void main(String[] args)
{
// 获取数组
int intArr[] = { 10, 20, 15, 22, 35 };
Arrays.sort(intArr);
int intKey = 22;
// 打印关键字和相应的索引
System.out.println(
intKey + "在索引处发现 = "
+ Arrays.binarySearch(intArr, intKey));
}
}
输出
22在索引处发现 = 3
示例 3： binarySearch(array, fromIndex, toIndex, key, Comparator) 方法
该方法使用二分查找算法在指定的数组范围内搜索指定的对象。
// Java程序演示Arrays.binarySearch()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// 获取数组
int intArr[] = { 10, 20, 15, 22, 35 };
Arrays.sort(intArr);
int intKey = 22;
System.out.println(
intKey
+ "在索引处发现 = "
+ Arrays
.binarySearch(intArr, 1, 3, intKey));
}
}
输出
22在索引处发现 = -4
示例 4： compare(array 1, array 2) 方法
// Java程序演示Arrays.compare()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// 获取数组
int intArr[] = { 10, 20, 15, 22, 35 };
// 获取第二个数组
int intArr1[] = { 10, 15, 22 };
// 比较两个数组
System.out.println("整数数组的比较结果: "
+ Arrays.compare(intArr, intArr1));
}
}
输出
整数数组的比较结果: 1
示例 5： compareUnsigned(array 1, array 2)方法
// Java程序演示
// Arrays.compareUnsigned()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// 获取第一个数组
int intArr[] = { 10, 20, 15, 22, 35 };
// 获取第二个数组
int intArr1[] = { 10, 15, 22 };
// 比较两个数组
System.out.println("Integer Arrays on comparison: "
+ Arrays.compareUnsigned(intArr, intArr1));
}
}
输出
Integer Arrays on comparison: 1
示例6： copyOf(originalArray, newLength)方法
// Java程序演示
// Arrays.copyOf()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// 获取数组
int intArr[] = { 10, 20, 15, 22, 35 };
// 打印数组元素
System.out.println("Integer Array: "
+ Arrays.toString(intArr));
System.out.println("\nNew Arrays by copyOf:\n");
System.out.println("Integer Array: "
+ Arrays.toString(
Arrays.copyOf(intArr, 10)));
}
}
输出
Integer Array: [10, 20, 15, 22, 35]
New Arrays by copyOf:
Integer Array: [10, 20, 15, 22, 35, 0, 0, 0, 0, 0]
示例7： copyOfRange(originalArray, fromIndex, endIndex)方法
// Java程序演示
// Arrays.copyOfRange()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// 获取数组
int intArr[] = { 10, 20, 15, 22, 35 };
// 打印数组元素
System.out.println("Integer Array: "
+ Arrays.toString(intArr));
System.out.println("\nNew Arrays by copyOfRange:\n");
// 将数组复制到新长度数组中
System.out.println("Integer Array: "
+ Arrays.toString(
Arrays.copyOfRange(intArr, 1, 3)));
}
}
输出
Integer Array: [10, 20, 15, 22, 35]
New Arrays by copyOfRange:
Integer Array: [20, 15]
示例8： deepEquals(Object[] a1, Object[] a2)方法
// Java程序演示
// Arrays.deepEquals()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// 获取数组
int intArr[][] = { { 10, 20, 15, 22, 35 } };
// 获取第二个数组
int intArr1[][] = { { 10, 15, 22 } };
// 比较两个数组
System.out.println("Integer Arrays on comparison: "
+ Arrays.deepEquals(intArr, intArr1));
}
}
输出
Integer Arrays on comparison: false
示例9： deepHashCode(Object[] a) 方法
//Java程序演示
//Arrays.deepHashCode()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
//获取数组
int intArr[][] = {{10, 20, 15, 22, 35}};
//获取数组的深度哈希码
System.out.println("整型数组: "
+ Arrays.deepHashCode(intArr));
}
}
输出结果
整型数组: 38475344
Example 10: deepToString(Object[] a) 方法
//Java程序演示
//Arrays.deepToString()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
//获取数组
int intArr[][] = {{10, 20, 15, 22, 35}};
//获取数组的深度字符串
System.out.println("整型数组: "
+ Arrays.deepToString(intArr));
}
}
输出结果
整型数组: [[10, 20, 15, 22, 35]]
Example 11: equals(array1, array2) 方法
//Java程序演示
//Arrays.equals()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
//获取数组
int intArr[] = {10, 20, 15, 22, 35};
//获取第二个数组
int intArr1[] = {10, 15, 22};
//比较两个数组
System.out.println("整型数组比较: "
+ Arrays.equals(intArr, intArr1));
}
}
输出结果
整型数组比较: false
Example 12: fill(originalArray, fillValue) 方法
//Java程序演示
//Arrays.fill()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
//获取数组
int intArr[] = {10, 20, 15, 22, 35};
int intKey = 22;
Arrays.fill(intArr, intKey);
//填充数组
System.out.println("整型数组填充: "
+ Arrays.toString(intArr));
}
}
输出结果
整型数组填充: [22, 22, 22, 22, 22]
Example 13: hashCode(originalArray) 方法
//Java程序演示
//Arrays.hashCode()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
//获取数组
int intArr[] = {10, 20, 15, 22, 35};
//获取数组的哈希码
System.out.println("整型数组: "
+ Arrays.hashCode(intArr));
}
}
输出结果
整型数组: 38475313
示例 14:
mismatch(array1, array2) 方法
// Java程序演示
// Arrays.sort()方法
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args)
{
// 获取数组
String[] strArr = { "A", "B", "C", "D", "E" };
// 指定比较器来排序数组
Arrays.sort(strArr, 1, 3, new myComparator());
System.out.println("String Array: "
+ Arrays.toString(strArr));
}
}
// 为比较元素创建自定义比较器
class myComparator implements Comparator {
public int compare(String a, String b)
{
return b.compareTo(a);
}
}
输出
String Array: [A, C, B, D, E]
// Java程序演示比较器接口的工作
import java.util.*;
import java.lang.*;
import java.io.*;
// 表示学生的类。
class Student：
int rollno;
String name, address;
// 构造函数
public Student(int rollno, String name, String address){
this.rollno = rollno;
this.name = name;
this.address = address;
}
// 标准输出学生的详细信息
public String toString(){
return this.rollno + " "
+ this.name + " "
+ this.address;
}
}
class Sortbyroll implements Comparator {
// 用于按升序排序的比较器
public int compare(Student a, Student b){
return a.rollno - b.rollno;
}
}
// 驱动程序
class Main {
public static void main(String[] args){
Student[] arr = { new Student(111, "bbbb", "london"),
new Student(131, "aaaa", "nyc"),
new Student(121, "cccc", "jaipur") };
System.out.println("Unsorted");
for (int i = 0; i < arr.length; i++)
System.out.println(arr[i]);
Arrays.sort(arr, 1, 2, new Sortbyroll());
System.out.println("\nSorted by rollno");
for (int i = 0; i < arr.length; i++)
System.out.println(arr[i]);
}
}
输出
Unsorted
111 bbbb london
131 aaaa nyc
121 cccc jaipur
Sorted by rollno
111 bbbb london
131 aaaa nyc
121 cccc jaipur
示例19： sort(T[] a，Comparator super T> c)方法
// Java程序演示比较器接口的工作
import java.util.*;
import java.lang.*;
import java.io.*;
// 表示学生的类。
class Student {
int rollno;
String name, address;
// 构造函数
public Student(int rollno, String name, String address){
this.rollno = rollno;
this.name = name;
this.address = address;
}
// 标准输出学生的详细信息
public String toString(){
return this.rollno + " "
+ this.name + " "
+ this.address;
}
}
class Sortbyroll implements Comparator {
// 用于按升序排序的比较器
public int compare(Student a, Student b){
return a.rollno - b.rollno;
}
}
// 驱动程序
class Main {
public static void main(String[] args){
Student[] arr = { new Student(111, "bbbb", "london"),
new Student(131, "aaaa", "nyc"),
new Student(121, "cccc", "jaipur") };
System.out.println("Unsorted");
for (int i = 0; i < arr.length; i++)
System.out.println(arr[i]);
Arrays.sort(arr, new Sortbyroll());
System.out.println("\nSorted by rollno");
for (int i = 0; i < arr.length; i++)
System.out.println(arr[i]);
}
}
输出
Unsorted
111 bbbb london
131 aaaa nyc
121 cccc jaipur
Sorted by rollno
111 bbbb london
121 cccc jaipur
131 aaaa nyc
示例20： spliterator（originalArray）方法
// Java程序演示Arrays.spliterator()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// 获取数组
int intArr[] = { 10, 20, 15, 22, 35 };
// 使用普通排序对数组进行排序
System.out.println("整数数组: "
+ Arrays.spliterator(intArr));
}
}
输出
整数数组: java.util.Spliterators$IntArraySpliterator@4e50df2e
示例21: spliterator(originalArray, fromIndex, endIndex) 方法
// Java程序演示Arrays.spliterator()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// 获取数组
int intArr[] = { 10, 20, 15, 22, 35 };
// 使用普通排序对数组进行排序
System.out.println("整数数组: "
+ Arrays.spliterator(intArr, 1, 3));
}
}
输出
整数数组: java.util.Spliterators$IntArraySpliterator@4e50df2e
示例22: stream(originalArray) 方法
// Java程序演示Arrays.stream()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// 获取数组
int intArr[] = { 10, 20, 15, 22, 35 };
// 从数组中获取流
System.out.println("整数数组: "
+ Arrays.stream(intArr));
}
}
输出
整数数组: java.util.stream.IntPipeline$Head@7291c18f
示例23: toString(originalArray) 方法
// Java程序演示Arrays.toString()方法
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// 获取数组
int intArr[] = { 10, 20, 15, 22, 35 };
// 在一行中打印元素
System.out.println("整数数组: "
+ Arrays.toString(intArr));
}
}
输出
整数数组: [10, 20, 15, 22, 35]