Arrays 工具类详解
目录
一、排序操作（核心常用）
（1）基本类型数组排序
（2）对象数组排序
二、搜索操作（高效查找）
三、数组复制（常用工具）
四、数组与列表转换（桥接集合）
五、相等与比较（判断数组一致性）
（1）判断数组是否相等
（2）多维数组深层比较
（3）字典序比较
六、填充操作（初始化数组）
七、字符串表示（调试与输出）
八、总结
在阅读文档时，我发现这个Arrays怎么这么多鬼东西，直接把我看头晕了……（T _ T）
所以我就想着，挑出一些重要的且常用的。
一、排序操作（核心常用）
排序是数组操作中最频繁的需求之一，Arrays 提供了单线程和并行排序两种方式，其中单线程排序更常用。
方法示例 功能说明 关键特点 sort(int[] a)对基本类型数组（int、byte、char 等）按升序排序 支持所有基本类型，直接修改原数组 sort(Object[] a)对对象数组按自然排序（元素需实现 Comparable）升序排序依赖元素的 compareTo()方法sort(T[] a, Comparator<? super T> c)对对象数组按指定比较器排序 灵活定制排序规则，如降序、按对象属性排序 sort(int[] a, int fromIndex, int toIndex)对数组的指定范围（ [fromIndex, toIndex)）排序仅排序部分元素，不影响其他位置
（1）基本类型数组排序
import java.util.Arrays;
public class test{public static void main(String[] args) {int[] nums = {3, 1, 4, 2};Arrays.sort(nums); // 对整个数组升序排序System.out.println(Arrays.toString(nums)); // 输出：[1, 2, 3, 4]// 对指定范围排序（左闭右开 [fromIndex, toIndex)）int[] arr = {5, 2, 9, 1, 5, 6};Arrays.sort(arr, 1, 4); // 仅排序索引 1-3 的元素System.out.println(Arrays.toString(arr)); // 输出：[5, 1, 2, 9, 5, 6]}}（2）对象数组排序
对象数组排序有两种方式：依赖元素的自然排序（实现 Comparable 接口），或通过 Comparator 自定义排序。
import java.util.Arrays;// 定义一个实现 Comparable 接口的 Student 类
class Student implements Comparable<Student> {private String name;private int age;// 构造方法public Student(String name, int age) {this.name = name;this.age = age;}// getter 方法public String getName() {return name;}public int getAge() {return age;}// setter 方法public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}// 重写 toString 方法，方便打印输出@Overridepublic String toString() {return "Student{name='" + name + "', age=" + age + "}";}// 实现 compareTo 方法，按年龄升序排序@Overridepublic int compareTo(Student o) {// 正数：当前对象大；负数：当前对象小；0：相等return this.age - o.age;}
}public class StudentSortDemo {public static void main(String[] args) {// 创建学生数组Student[] students = {new Student("张三", 20),new Student("李四", 18),new Student("王五", 22)};System.out.println("排序前的学生数组：");for (Student student : students) {System.out.println(student);}// 使用 Arrays.sort() 进行排序（依赖 Student 类的自然排序）Arrays.sort(students);System.out.println("\n按年龄升序排序后的学生数组：");for (Student student : students) {System.out.println(student);}}
}运行结果：
排序前的学生数组：
Student{name='张三', age=20}
Student{name='李四', age=18}
Student{name='王五', age=22}按年龄升序排序后的学生数组：
Student{name='李四', age=18}
Student{name='张三', age=20}
Student{name='王五', age=22}
注意 ：如果需要按年龄降序排序，只需修改
compareTo()方法的返回值即可：
@Override
public int compareTo(Student o) {return o.age - this.age; // 按年龄降序
}自定义比较
// 实现 compareTo 方法，按姓名升序排序（替换原来按年龄排序的逻辑）
@Override
public int compareTo(Student o) {// 利用String的compareTo方法实现姓名的自然排序return this.name.compareTo(o.name);
}二、搜索操作（高效查找）
基于二分查找算法，适用于快速定位元素位置。
注意：使用 二分查找法 的前提，需数组提前有序
方法示例 功能说明 关键特点 binarySearch(int[] a, int key)在有序的基本类型数组中查找 key找到则返回索引，未找到返回 -(插入点 + 1)binarySearch(Object[] a, Object key)在有序的对象数组中查找 key（元素需实现Comparable）依赖元素的自然排序，数组必须先排序 binarySearch(T[] a, T key, Comparator<? super T> c)按指定比较器在有序数组中查找 key需配合比较器对应的排序规则使用 binarySearch(int[] a, int fromIndex, int toIndex, int key)在数组的指定范围中查找 key仅搜索 [fromIndex, toIndex)区间
import java.util.Arrays;public class BinarySearchDemo {public static void main(String[] args) {// 定义一个已排序的int数组（二分查找必须在有序数组上进行）int[] sortedNums = {10, 20, 30, 40, 50};// 1. 查找存在的元素int target1 = 30;int index1 = Arrays.binarySearch(sortedNums, target1);System.out.println("查找元素 " + target1 + " 的结果：");if (index1 >= 0) {System.out.println("找到元素，索引位置：" + index1);} else {System.out.println("未找到元素");}// 2. 查找不存在的元素int target2 = 35;int index2 = Arrays.binarySearch(sortedNums, target2);System.out.println("\n查找元素 " + target2 + " 的结果：");if (index2 >= 0) {System.out.println("找到元素，索引位置：" + index2);} else {// 计算应该插入的位置：-index2 - 1int insertPosition = -index2 - 1;System.out.println("未找到元素，返回值：" + index2);System.out.println("该元素应插入的位置：" + insertPosition);}}
}返回值规则：
- 当元素存在时：返回该元素在数组中的索引（>= 0）
- 当元素不存在时：返回
-(插入点 + 1)（< 0），其中插入点是该元素应该插入的位置
对象数组搜索需配合排序规则（片段例子）：
// 先按年龄排序
Arrays.sort(students);
// 查找年龄为 20 的学生（需重写 Student 的 equals 方法）
Student target = new Student("张三", 20);
int pos = Arrays.binarySearch(students, target);三、数组复制（常用工具）
快速复制数组的全部或部分元素，常用于扩展数组、截取子数组等场景
方法示例 功能说明 关键特点 copyOf(int[] original, int newLength)复制原数组到新数组，新数组长度为 newLength若新长度 > 原长度，多余部分用默认值填充（如 int 补 0）；若更小则截断 copyOfRange(int[] original, int from, int to)复制原数组中 [from, to)范围的元素到新数组新数组长度为 to - from，直接截取指定区间
import java.util.Arrays;public class ArrayCopyDemo {public static void main(String[] args) {int[] original = {1, 2, 3, 4};// 打印原始数组System.out.println("原始数组: " + Arrays.toString(original));// 复制并扩展数组（长度不足则补默认值）int[] expanded = Arrays.copyOf(original, 6); System.out.println("扩展后的数组: " + Arrays.toString(expanded));// 输出：[1, 2, 3, 4, 0, 0]（int 类型默认补 0）// 截取子数组（[from, to) 范围）int[] subArray = Arrays.copyOfRange(original, 1, 3); System.out.println("截取的子数组: " + Arrays.toString(subArray));// 输出：[2, 3]（包含索引 1，不包含索引 3）}
}四、数组与列表转换（桥接集合）
快速将数组转为列表，方便使用集合框架的方法（如遍历、判断包含等）。
方法 功能说明 关键特点 asList(T... a)将数组转为 List<T>（固定大小）1. 返回的列表不可增删元素（会抛 UnsupportedOperationException）；
2. 列表修改会同步反映到原数组（底层仍为数组）；
3. 基本类型数组会被当作单个对象（需用包装类数组，如Integer[]）
asList() 可将数组转为 List，方便利用集合的方法（如 contains()、forEach()），但有两个注意点：
会报错
import java.util.Arrays;
import java.util.List;public class test {public static void main(String[] args) {// 基本类型数组会被当作单个对象（需用包装类）Integer[] nums = {1, 2, 3};List<Integer> list = Arrays.asList(nums);// 1. 返回的列表是固定大小，不可增删元素list.add(4); // 抛出 UnsupportedOperationException// 2. 列表修改会同步到原数组list.set(0, 100);System.out.println(nums[0]); // 输出：100（原数组被修改）}
}修改：
List<Integer> mutableList = new ArrayList<>(Arrays.asList(nums));改后：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class ConvertArrayToList {public static void main(String[] args) {Integer[] nums = {1, 2, 3};// 转换为可修改的列表List<Integer> mutableList = new ArrayList<>(Arrays.asList(nums));// 测试修改操作mutableList.add(4); // 支持添加元素mutableList.set(0, 100); // 支持修改元素// 输出列表内容System.out.println("可修改列表: " + mutableList); // 输出：[100, 2, 3, 4]// 原数组不受影响System.out.println("原数组第一个元素: " + nums[0]); // 输出：1（原数组未被修改）}
}五、相等与比较（判断数组一致性）
判断两个数组是否相等，或比较数组的字典顺序。
方法示例 功能说明 关键特点 equals(int[] a, int[] a2)判断两个基本类型数组是否相等（长度相同且所有元素对应相等） 对多维数组仅比较引用，不深入元素 deepEquals(Object[] a1, Object[] a2)判断多维数组是否 “深层相等”（递归比较所有层级的元素） 解决 equals()对多维数组的局限性（如Object[][]比较）compare(int[] a, int[] b)按字典顺序比较两个数组（类似字符串比较） 返回正数（a 大）、负数（b 大）或 0（相等）
（1）判断数组是否相等
import java.util.Arrays;public class ArrayComparisonDemo {public static void main(String[] args) {// （1）判断数组是否相等int[] a = {1, 2, 3};int[] b = {1, 2, 3};int[] c = {1, 2, 4};System.out.println("（1）数组是否相等比较：");System.out.println("a与b相等？" + Arrays.equals(a, b)); // trueSystem.out.println("a与c相等？" + Arrays.equals(a, c)); // false}
}（2）多维数组深层比较
import java.util.Arrays;public class ArrayComparisonDemo {public static void main(String[] args) {// （2）多维数组深层比较int[][] arr1 = {{1, 2}, {3, 4}};int[][] arr2 = {{1, 2}, {3, 4}};System.out.println("（2）多维数组深层比较：");System.out.println("arr1与arr2引用相等？" + Arrays.equals(arr1, arr2)); // false（引用不同）System.out.println("arr1与arr2深层元素相等？" + Arrays.deepEquals(arr1, arr2)); // true（深层元素相等）}
}（3）字典序比较
import java.util.Arrays;public class ArrayComparisonDemo {public static void main(String[] args) {// （3）字典序比较int[] x = {1, 3, 5};int[] y = {1, 2, 6};System.out.println("（3）字典序比较：");int result = Arrays.compare(x, y);System.out.println("x与y比较结果：" + result); // 1（x 大于 y，因 x[1]=3 > y[1]=2）System.out.println("比较说明：");System.out.println("返回值 > 0 表示 x 大于 y");System.out.println("返回值 = 0 表示 x 等于 y");System.out.println("返回值 < 0 表示 x 小于 y");}
}六、填充操作（初始化数组）
快速将数组的全部或部分元素设为指定值，常用于数组初始化。
fill(int[] a, int val)将数组所有元素填充为 val批量初始化，如 int[] arr = new int[5]; Arrays.fill(arr, 0);fill(Object[] a, int fromIndex, int toIndex, Object val)将数组 [fromIndex, toIndex)范围填充为val仅填充指定区间，适合局部初始化
// 填充整个数组
int[] filled = new int[5];
Arrays.fill(filled, 10); // 所有元素设为 10// 填充指定范围
Arrays.fill(filled, 2, 4, 20); // 索引 2-3 设为 20
// 输出：[10, 10, 20, 20, 10]七、字符串表示（调试与输出）
将数组转为字符串，方便打印或日志输出。
toString(int[] a)返回数组的字符串表示（如 [1, 2, 3]）基本类型和对象数组均支持，直接展示元素 deepToString(Object[] a)返回多维数组的深层字符串表示 递归展示所有层级元素（如 [[1,2], [3,4]]）
String[] words = {"Java", "Arrays", "Tool"};
System.out.println(Arrays.toString(words));
// 输出：[Java, Arrays, Tool]// 多维数组用 deepToString()
System.out.println(Arrays.deepToString(arr1));
// 输出：[[1, 2], [3, 4]]八、总结
Arrays 类是处理数组的 “瑞士军刀”，掌握其核心方法能极大简化代码：
排序用
sort()，支持自然排序和自定义排序；搜索用
binarySearch()，前提是数组有序；复制用
copyOf()和copyOfRange()，灵活处理数组长度；转换用
asList()，但需注意其固定大小特性；比较用
equals()和deepEquals()，区分一维与多维数组。