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 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 { 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 方法，方便打印输出 @Override public String toString() { return \"Student{name=\'\" + name + \"\', age=\" + age + \"}\"; } // 实现 compareTo 方法，按年龄升序排序 @Override public 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()方法的返回值即可：
@Overridepublic int compareTo(Student o) { return o.age - this.age; // 按年龄降序}自定义比较
// 实现 compareTo 方法，按姓名升序排序（替换原来按年龄排序的逻辑）@Overridepublic 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 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 - 1 int 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（固定大小）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 list = Arrays.asList(nums); // 1. 返回的列表是固定大小，不可增删元素 list.add(4); // 抛出 UnsupportedOperationException // 2. 列表修改会同步到原数组 list.set(0, 100); System.out.println(nums[0]); // 输出：100（原数组被修改） }}修改：
List 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 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)); // true System.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()，区分一维与多维数组。
