Java 常用类 Arrays：从基础到进阶的数组操作指南

🔥「炎码工坊」技术弹药已装填！
点击关注 → 解锁工业级干货【工具实测|项目避坑|源码燃烧指南】

在 Java 开发中，数组是处理数据的基础结构，但其原生操作能力有限。为此，Java 提供了强大的工具类 java.util.Arrays，通过丰富的静态方法简化了数组的排序、搜索、填充、比较等操作。本文将深入解析 Arrays类的核心功能、高级技巧及性能优化策略，助你高效驾驭数组操作。

一、`Arrays` 类概览

Arrays 类位于 java.util 包中，所有方法均为静态方法，无需实例化即可调用。其核心设计目标是提升数组操作的效率与代码简洁性。
特点：

私有构造器：防止实例化，直接通过类名调用方法。
兼容性：支持基本类型（int[]、double[]）和对象数组（String[]、自定义类数组）。
性能优化：内部实现基于高效算法（如双轴快速排序、二分查找）。

二、核心方法详解与实战示例

1. 排序：`Arrays.sort()`

功能：对数组进行升序排序，支持部分排序和自定义排序规则。
示例：

int[] arr = {5, 2, 8, 1, 9};
Arrays.sort(arr); // 全局排序 → [1, 2, 5, 8, 9]

// 对部分数组排序（索引0到3，左闭右开）
Arrays.sort(arr, 0, 3); // 原数组 [5, 2, 8, 1, 9] → 排序后 [2, 5, 8, 1, 9]

自定义排序：

// 对字符串数组忽略大小写排序
String[] strArr = {"Zhang", "alice", "Bob"};
Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER); // → ["alice", "Bob", "Zhang"]

// 反向排序
Arrays.sort(strArr, Collections.reverseOrder());

性能分析：

基本类型：采用 双轴快速排序（Dual-Pivot Quicksort），时间复杂度为 O(n log n)。
对象数组：使用 TimSort（稳定排序），适合部分有序数据。

2. 二分查找：`Arrays.binarySearch()`

功能：在已排序数组中快速定位目标元素索引，未找到时返回插入位置（-index -1）。
示例：

int[] sortedArr = {1, 3, 5, 7, 9};
int index = Arrays.binarySearch(sortedArr, 5); // 返回索引 2

// 查找不存在的元素
int insertPos = Arrays.binarySearch(sortedArr, 6); // 返回 -4（应插入到索引3）

注意事项：

数组必须 预先排序，否则结果不可预测。
对对象数组需确保排序规则一致（如使用 Comparator）。

3. 填充与复制：`Arrays.fill()` 与 `Arrays.copyOf()`

填充数组：

int[] arr = new int[5];
Arrays.fill(arr, 10); // [10, 10, 10, 10, 10]

复制数组：

int[] original = {1, 2, 3};
int[] copy = Arrays.copyOf(original, 5); // 长度不足时补0 → [1, 2, 3, 0, 0]

// 截取部分数组
int[] subArray = Arrays.copyOfRange(original, 0, 2); // [1, 2]

底层原理：

copyOf() 和 copyOfRange() 内部调用 System.arraycopy()，实现高效内存拷贝（时间复杂度 O(n)）。

4. 数组比较：`Arrays.equals()` 与 `Arrays.deepEquals()`

浅层比较：

int[] a1 = {1, 2};
int[] a2 = {1, 2};
boolean isEqual = Arrays.equals(a1, a2); // true

深度比较（多维数组）：

int[][] matrix1 = {{1, 2}, {3, 4}};
int[][] matrix2 = {{1, 2}, {3, 4}};
boolean deepEqual = Arrays.deepEquals(matrix1, matrix2); // true

对象数组比较：

默认比较引用地址，需重写 equals() 方法以实现值比较。

5. 数组转换：`Arrays.toString()` 与 `Arrays.asList()`

打印数组内容：

int[] arr = {1, 2, 3};
System.out.println(Arrays.toString(arr)); // 输出 [1, 2, 3]

转换为 List：

String[] strArr = {"Java", "Python", "C++"};
List<String> list = Arrays.asList(strArr);

注意事项：

asList() 返回的 List 是固定大小的视图，不支持增删操作。

三、高级技巧与性能优化

1. 并行操作：`parallelSort()` 与 `parallelSetAll()`

并行排序：

int[] largeArr = largeDataSet();
Arrays.parallelSort(largeArr); // 多线程排序，适用于大数据量（JDK8+）

并行填充：

int[] arr = new int[1000];
Arrays.parallelSetAll(arr, i -> i * 2); // 每个元素并发赋值为索引的2倍

适用场景：

数据量较大（如 >10^5）时，parallelSort() 比 sort() 更高效。

2. 自定义排序规则：`Comparator` 进阶

复合排序：

class Person {
    String name;
    int age;
}

Person[] people = ...;
// 先按年龄升序，再按姓名降序
Arrays.sort(people, (p1, p2) -> {
    int ageCompare = Integer.compare(p1.age, p2.age);
    return ageCompare != 0 ? ageCompare : p2.name.compareTo(p1.name);
});

3. 多维数组的深度操作

深度排序与比较：

int[][] matrix = {{3, 2}, {1, 4}, {5, 0}};
Arrays.sort(matrix, (a, b) -> Integer.compare(a[0], b[0])); // 按第一列排序
Arrays.deepToString(matrix); // 输出 [[1, 4], [3, 2], [5, 0]]

四、常见问题与避坑指南

1. 对象数组的 `equals()` 陷阱

String[] a1 = {"a", "b"};
String[] a2 = {"a", "b"};
System.out.println(Arrays.equals(a1, a2)); // true

Object[] o1 = a1;
Object[] o2 = a2;
System.out.println(Arrays.equals(o1, o2)); // false（调用 Object.equals()）
System.out.println(Arrays.deepEquals(o1, o2)); // true（推荐）

2. 排序稳定性

Arrays.sort() 对原始数据有副作用（修改原数组），必要时先复制副本。

3. 多维数组的填充

int[][] matrix = new int[3][3];
Arrays.fill(matrix, new int[]{1, 2, 3}); // 错误！所有行引用同一数组
// 正确方式：逐行填充
for (int i = 0; i < matrix.length; i++) {
    Arrays.fill(matrix[i], i + 1);
}