Java数组排序有哪些常用方法？如何实现不同场景下的数组排序？

Java数组排序是日常开发中非常常见的操作，针对不同的数组类型和排序需求，有多种实现方式可以选择，既可以调用JDK提供的现成工具，也可以手动实现经典排序算法。

一、使用JDK内置的Arrays.sort方法排序

java.util.Arrays类提供了sort方法，是Java中最常用的数组排序方式，支持基本类型数组和对象数组的排序，内部采用了优化的归并排序和快速排序结合的实现，性能稳定。

1. 基本类型数组排序

对于int、double等基本类型的数组，Arrays.sort会按照自然升序进行排序，示例如下：

import java.util.Arrays;

public class BasicArraySort {
    public static void main(String[] args) {
        int[] intArray = {5, 2, 8, 1, 9, 3};
        System.out.println("排序前数组：" + Arrays.toString(intArray));
        // 对int数组进行升序排序
        Arrays.sort(intArray);
        System.out.println("排序后数组：" + Arrays.toString(intArray));

        double[] doubleArray = {3.2, 1.5, 4.8, 2.1};
        Arrays.sort(doubleArray);
        System.out.println("double数组排序后：" + Arrays.toString(doubleArray));
    }
}

上述代码运行后，intArray会变为[1,2,3,5,8,9]，doubleArray会变为[1.5,2.1,3.2,4.8]，都是默认的升序排列。

2. 对象数组自定义规则排序

如果是对对象数组排序，或者需要自定义排序规则，可以配合Comparator接口实现。比如我们有一个Student类，需要按照年龄升序排序：

import java.util.Arrays;
import java.util.Comparator;

class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + "}";
    }
}

public class ObjectArraySort {
    public static void main(String[] args) {
        Student[] students = {
            new Student("张三", 20),
            new Student("李四", 18),
            new Student("王五", 22)
        };
        System.out.println("排序前：" + Arrays.toString(students));
        // 按照年龄升序排序
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                // 返回负数表示s1年龄小于s2，排在前面
                return Integer.compare(s1.getAge(), s2.getAge());
            }
        });
        System.out.println("按年龄升序排序后：" + Arrays.toString(students));
    }
}

如果需要降序排序，只需要把compare方法中的两个参数调换位置即可，即return Integer.compare(s2.getAge(), s1.getAge())。

二、手动实现经典排序算法

除了使用内置方法，手动实现排序算法有助于理解排序的底层逻辑，下面介绍两种常见的手动排序实现。

1. 冒泡排序实现

冒泡排序的核心逻辑是相邻元素两两比较，把较大的元素往后挪，每一轮会把当前未排序部分的最大值放到末尾，示例如下：

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int length = arr.length;
        // 外层循环控制排序轮数
        for (int i = 0; i < length - 1; i++) {
            // 内层循环控制每轮比较的次数，每轮后最大的元素已到末尾，所以长度减i
            for (int j = 0; j < length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换相邻元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 1, 9, 3};
        System.out.println("冒泡排序前：" + Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("冒泡排序后：" + Arrays.toString(arr));
    }
}

2. 快速排序实现

快速排序是效率较高的排序算法，核心思想是选择一个基准元素，把数组分为比基准小和比基准大的两部分，然后递归处理两部分，示例如下：

import java.util.Arrays;

public class QuickSort {
    public static void quickSort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int pivot = arr[left]; // 选择最左边的元素作为基准
        int i = left;
        int j = right;
        while (i < j) {
            // 从右往左找比基准小的元素
            while (i < j && arr[j] >= pivot) {
                j--;
            }
            // 从左往右找比基准大的元素
            while (i < j && arr[i] <= pivot) {
                i++;
            }
            // 交换找到的两个元素
            if (i < j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        // 把基准元素放到正确位置
        arr[left] = arr[i];
        arr[i] = pivot;
        // 递归处理左右两部分
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }

    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 1, 9, 3};
        System.out.println("快速排序前：" + Arrays.toString(arr));
        quickSort(arr, 0, arr.length - 1);
        System.out.println("快速排序后：" + Arrays.toString(arr));
    }
}

三、不同排序方式的适用场景

如果是日常开发快速实现需求，优先选择Arrays.sort方法，它经过了充分的优化，性能和稳定性都有保障。如果是学习排序原理，或者需要定制非常特殊的排序逻辑（比如内置方法无法满足的场景），可以选择手动实现排序算法。对于基本类型的小规模数组，冒泡排序逻辑简单容易理解，但大规模数据下快速排序的效率更高。

Java数组排序Arrays_sortComparator冒泡排序快速排序修改时间：2026-06-11 14:36:30