Java如何给数组排序？

在Java中给数组排序有多种高效且灵活的方式,以下是详细方法和实践建议：

使用 Arrays.sort() 方法（最常用）

适用场景：快速对基本类型或对象数组排序
代码示例：

import java.util.Arrays;
// 1. 基本类型数组（如int）
int[] numbers = {5, 3, 9, 1};
Arrays.sort(numbers); // 升序排序
System.out.println(Arrays.toString(numbers)); // 输出 [1, 3, 5, 9]
// 2. 对象数组（如String）
String[] names = {"John", "Alice", "Bob"};
Arrays.sort(names); // 按字典序升序
System.out.println(Arrays.toString(names)); // 输出 [Alice, Bob, John]
// 3. 自定义排序规则（通过Comparator）
Integer[] nums = {10, 5, 8};
Arrays.sort(nums, (a, b) -> b - a); // 降序排序
System.out.println(Arrays.toString(nums)); // 输出 [10, 8, 5]

特点：

• 时间复杂度：平均 O(n log n)（使用双轴快速排序或归并排序）
• 原地排序（直接修改原数组）
• 对象数组需实现 Comparable 接口，否则需提供 Comparator

使用 Collections.sort()（针对List集合）

适用场景：对 ArrayList 等List集合排序
代码示例：

import java.util.ArrayList;
import java.util.Collections;
ArrayList<Integer> list = new ArrayList<>();
list.add(30);
list.add(10);
list.add(20);
Collections.sort(list); // 升序排序
System.out.println(list); // 输出 [10, 20, 30]
// 自定义排序
Collections.sort(list, Collections.reverseOrder()); // 降序

Java 8 Stream API（函数式编程）

适用场景：需链式操作或生成新数组时
代码示例：

import java.util.Arrays;
int[] arr = {7, 2, 5};
// 升序排序并生成新数组
int[] sortedArr = Arrays.stream(arr)
                        .sorted()
                        .toArray();
System.out.println(Arrays.toString(sortedArr)); // 输出 [2, 5, 7]
// 对象数组自定义排序
String[] languages = {"Java", "Python", "C++"};
String[] sortedLangs = Arrays.stream(languages)
                             .sorted((s1, s2) -> s2.length() - s1.length()) // 按字符串长度降序
                             .toArray(String[]::new);

手动实现排序算法（理解原理）

示例：快速排序（实际开发建议用内置方法）

public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pivot = partition(arr, low, high);
        quickSort(arr, low, pivot - 1);
        quickSort(arr, pivot + 1, high);
    }
}
private static int partition(int[] arr, int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, high);
    return i + 1;
}
private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

方法对比与最佳实践

最佳实践：

1. 优先使用内置方法：Arrays.sort() 和 Collections.sort() 经过高度优化。
2. 对象排序规则：
   • 实现 Comparable 接口定义自然顺序
   • 使用 Comparator 实现动态排序（如 Comparator.comparing(Person::getAge)）
3. 稳定性要求：对象排序默认稳定（相等元素顺序不变）,基本类型不稳定。
4. 大数据量优化：用 Arrays.parallelSort() 并行排序（Java 8+）。

常见问题

Q：如何对二维数组排序？

int[][] matrix = {{2,5}, {1,9}, {3,4}};
Arrays.sort(matrix, (a, b) -> a[0] - b[0]); // 按第一列升序

Q：如何避免修改原数组？

int[] original = {6, 2, 4};
int[] copy = Arrays.copyOf(original, original.length);
Arrays.sort(copy); // 原数组不受影响

Java数组排序的核心是 Arrays.sort()，它覆盖了大多数场景，对于集合类型使用 Collections.sort()，函数式处理选择Stream API，自定义排序通过 Comparator 实现，避免重复造轮子，实际开发中,内置方法在性能和稳定性上远优于手动实现。

引用说明基于Oracle官方Java文档（Arrays类）及《Java核心技术 卷I》第14章，遵循Java 17规范，算法复杂度参考《算法导论》第三版。