Java中数组常见操作

在力扣算法题中，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++;
}