在力扣算法题中，Java对数组的常见操作及其复杂度：
1. 排序操作
Arrays.sort(nums); // 时间复杂度: O(nlogn)
Arrays.sort(nums, 1, 4); // 时间复杂度: O(klogk), k为排序范围大小// 自定义排序（需要转为Integer[]）
Integer[] integerNums = Arrays.stream(nums).boxed().toArray(Integer[]::new);
Arrays.sort(integerNums, (a, b) -> b - a); // O(nlogn)
2. 二分查找
Arrays.binarySearch(nums, 5); // 时间复杂度: O(logn)
Arrays.binarySearch(nums, 1, 4, 5); // 时间复杂度: O(logk), k为查找范围大小
3. 数组填充和复制
Arrays.fill(nums, -1); // 时间复杂度: O(n)
Arrays.fill(nums, 1, 4, 99); // 时间复杂度: O(k), k为填充范围大小Arrays.copyOf(nums, nums.length); // 时间复杂度: O(n), 空间复杂度: O(n)
Arrays.copyOfRange(nums, 1, 4); // 时间复杂度: O(k), 空间复杂度: O(k)
4. 数组比较和转换
Arrays.equals(arr1, arr2); // 时间复杂度: O(n)
Arrays.toString(arr1); // 时间复杂度: O(n), 空间复杂度: O(n)
Arrays.deepToString(matrix); // 时间复杂度: O(n×m), 空间复杂度: O(n×m)
5. Stream API 操作（Java 8+）
// 终端操作（触发计算）
Arrays.stream(nums).sum(); // 时间复杂度: O(n)
Arrays.stream(nums).max().getAsInt(); // 时间复杂度: O(n)
Arrays.stream(nums).min().getAsInt(); // 时间复杂度: O(n)
Arrays.stream(nums).average(); // 时间复杂度: O(n)// 中间操作 + 终端操作
Arrays.stream(nums).filter(x -> x % 2 == 0).toArray(); // 时间复杂度: O(n), 空间复杂度: O(n)
Arrays.stream(nums).map(x -> x * x).toArray(); // 时间复杂度: O(n), 空间复杂度: O(n)
Arrays.stream(nums).sorted().toArray(); // 时间复杂度: O(nlogn), 空间复杂度: O(n)
Arrays.stream(nums).distinct().toArray(); // 时间复杂度: O(n), 空间复杂度: O(n)
6. 其他实用操作
Arrays.setAll(nums, i -> i * i); // 时间复杂度: O(n)// 数组转List（注意返回的List不可变）
Arrays.asList(1, 2, 3); // 时间复杂度: O(n), 空间复杂度: O(n)// 可变List转换
List<Integer> list = Arrays.stream(nums).boxed().collect(Collectors.toList()); // O(n), O(n)
int[] array = list.stream().mapToInt(Integer::intValue).toArray(); // O(n), O(n)
7. 多维数组操作
int[][] matrix = new int[m][n];// 多维数组排序（按行排序）
Arrays.sort(matrix, (a, b) -> a[0] - b[0]); // 时间复杂度: O(mlogm × n)// 遍历多维数组
for (int[] row : matrix) {Arrays.sort(row); // 总时间复杂度: O(m × nlogn)
}
8. 特殊操作复杂度分析
// 链式操作复杂度分析
int result = Arrays.stream(nums).filter(x -> x > 0) // O(n).map(x -> x * 2) // O(n).distinct() // O(n).sorted() // O(nlogn).sum(); // O(n)
// 总时间复杂度: O(nlogn)// 嵌套操作
for (int i = 0; i < n; i++) {Arrays.sort(matrix[i]); // 总时间复杂度: O(m × nlogn)
}// 二分查找组合
Arrays.sort(nums); // O(nlogn)
for (int i = 0; i < n; i++) {Arrays.binarySearch(nums, target); // 总时间复杂度: O(nlogn)
}
复杂度总结表
| 操作 | 时间复杂度 | 空间复杂度 | 说明 |
|---|---|---|---|
Arrays.sort() |
O(nlogn) | O(logn)~O(n) | 快速排序的栈空间 |
Arrays.binarySearch() |
O(logn) | O(1) | 二分查找 |
Arrays.fill() |
O(n) | O(1) | 线性遍历 |
Arrays.copyOf() |
O(n) | O(n) | 需要新数组空间 |
Arrays.stream().sum() |
O(n) | O(1) | 累加操作 |
Arrays.stream().sorted() |
O(nlogn) | O(n) | 需要中间存储 |
| 数组遍历 | O(n) | O(1) | 基础操作 |
力扣中的实用建议
// 1. 优先考虑时间复杂度
// 如果 n ≤ 10^3，O(n²) 可接受
// 如果 n ≤ 10^5，O(nlogn) 可接受
// 如果 n ≤ 10^6，O(n) 可接受// 2. 空间复杂度优化
int[] result = new int[n]; // O(n) 空间
// vs
Arrays.sort(nums); // 原地排序，空间复杂度较低// 3. 避免不必要的流操作
// 不推荐（创建多个中间流）
long count = Arrays.stream(nums).filter(x -> x > 0).count();// 推荐（单次遍历）
int count = 0;
for (int num : nums) {if (num > 0) count++;
}