Java中Collections.sort方法使用方法

P粉602998670

发布时间：2025-09-20 17:24:01

379人浏览过

来源于php中文网

原创

Collections.sort方法用于对List进行排序，支持自然顺序和自定义Comparator两种方式，底层使用稳定的TimSort算法，时间复杂度为O(n log n)，需注意null处理、列表可修改性及比较逻辑性能。

java中collections.sort方法使用方法

Collections.sort

方法是Java中用于对

List

接口的实现类进行排序的一个非常实用的工具。说白了，它就是帮我们把列表里的元素按照一定的规则重新排列，可以是元素的自然顺序，也可以是我们自定义的比较逻辑。在我日常开发中，无论是处理用户输入、日志数据还是数据库查询结果，需要整理顺序的时候，这个方法几乎是条件反射般地会想到并使用。它隐藏了复杂的排序算法细节，让开发者能更专注于业务逻辑本身。

解决方案

Collections.sort

方法主要有两种使用方式，这取决于你的列表元素是否已经具备了“自然”的排序能力，或者你需要一种特别的排序规则。

1. 使用元素的自然顺序排序

如果你的列表中的元素类型实现了

Comparable

接口，那么它们就有了所谓的“自然顺序”。比如

String

、

Integer

等基本包装类都默认实现了

Comparable

。这种情况下，你只需要将列表传递给

Collections.sort

方法即可。

立即学习“Java免费学习笔记（深入）”；

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SortExample {
    public static void main(String[] args) {
        List names = new ArrayList<>();
        names.add("Alice");
        names.add("Charlie");
        names.add("Bob");
        names.add("David");

        System.out.println("原始列表: " + names); // 输出: 原始列表: [Alice, Charlie, Bob, David]

        Collections.sort(names); // 使用String的自然顺序（字母顺序）排序

        System.out.println("排序后列表: " + names); // 输出: 排序后列表: [Alice, Bob, Charlie, David]

        List numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(1);

        System.out.println("原始数字列表: " + numbers); // 输出: 原始数字列表: [5, 2, 8, 1]

        Collections.sort(numbers); // 使用Integer的自然顺序（数值大小）排序

        System.out.println("排序后数字列表: " + numbers); // 输出: 排序后数字列表: [1, 2, 5, 8]
    }
}

2. 使用自定义比较器（Comparator）排序

很多时候，我们列表里的对象并没有实现

Comparable

接口，或者我们需要按照多种不同的标准来排序（比如先按年龄排，年龄相同再按姓名排）。这时候，我们就需要提供一个

Comparator

对象。

Comparator

是一个函数式接口，它定义了一个

compare(T o1, T o2)

方法，用于比较两个对象。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Person {
    String name;
    int age;

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

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

public class CustomSortExample {
    public static void main(String[] args) {
        List people = new ArrayList<>();
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));
        people.add(new Person("Charlie", 35));
        people.add(new Person("David", 25)); // 注意David和Bob年龄相同

        System.out.println("原始人员列表: " + people);

        // 按照年龄升序排序
        Collections.sort(people, new Comparator() {
            @Override
            public int compare(Person p1, Person p2) {
                return Integer.compare(p1.age, p2.age); // p1.age - p2.age 也可以，但Integer.compare更安全，避免溢出
            }
        });
        System.out.println("按年龄排序后: " + people);
        // 输出可能为: [Person{name='Bob', age=25}, Person{name='David', age=25}, Person{name='Alice', age=30}, Person{name='Charlie', age=35}]

        // Java 8 以后，可以使用Lambda表达式，更简洁
        // 按照年龄升序，年龄相同则按姓名升序
        Collections.sort(people, (p1, p2) -> {
            int ageCompare = Integer.compare(p1.age, p2.age);
            if (ageCompare == 0) {
                return p1.name.compareTo(p2.name); // 年龄相同，按姓名排序
            }
            return ageCompare;
        });
        System.out.println("按年龄和姓名排序后: " + people);
        // 输出: [Person{name='Bob', age=25}, Person{name='David', age=25}, Person{name='Alice', age=30}, Person{name='Charlie', age=35}]
        // 实际输出会因为David和Bob的原始顺序而定，因为TimSort是稳定排序，但这里我们用姓名做了二次排序，会重新确定他们的顺序。
        // 正确输出应为: [Person{name='Bob', age=25}, Person{name='David', age=25}, Person{name='Alice', age=30}, Person{name='Charlie', age=35}]
    }
}

这个例子里，我个人觉得Lambda表达式的写法真是太香了，极大地简化了代码，让排序逻辑一目了然。

Collections.sort()与List.sort()有什么区别？

这个问题问得非常好，在Java 8及更高版本中，

List

接口自身也引入了一个

sort()

方法，这确实让一些开发者感到困惑，到底用哪个好呢？

简单来说，

Collections.sort(List list, Comparator c)

是一个静态方法，属于

java.util.Collections

工具类。它接受一个

List

对象和一个可选的

Comparator

作为参数，然后对传入的

List

进行原地排序。它的设计理念是作为集合操作的通用工具。

而

List.sort(Comparator c)

是

java.util.List

接口的一个默认方法（default method），这意味着所有

List

的实现类都自动拥有了这个方法。它直接在

List

实例上调用，并且必须传入一个

Comparator

（如果想用自然排序，可以传入

null

，但通常不推荐，因为这会依赖于

Comparable

，不如直接调用

Collections.sort(List)

或者

list.sort(Comparator.naturalOrder())

）。

从实现层面看，

List.sort()

方法通常会委托给

Arrays.sort()

来完成实际的排序工作。它可能会将

List

转换为一个数组，对数组进行排序，然后再将排序后的元素写回

List

。而

Collections.sort()

在内部也是使用

TimSort

算法（一种混合了归并排序和插入排序的稳定算法）。

我个人倾向于在Java 8及更高版本中使用

List.sort()

，原因有几点：

面向对象风格：
```
List.sort()
```
更符合面向对象的编程习惯，操作直接发生在对象自身上，而不是通过一个外部工具类。
简洁性： 尤其结合Lambda表达式，
```
list.sort((o1, o2) -> ...)
```
的写法非常直观和简洁。
可读性： 看到
```
List.sort()
```
，很明显就知道是对这个
```
List
```
进行排序。

不过，这不意味着

Collections.sort()

就过时了。如果你在维护一个老项目，或者习惯了使用

Collections

工具类，继续使用它也完全没问题。在功能上，两者最终都能达到相同的排序效果。

如何为自定义对象实现排序？

为自定义对象实现排序，通常有两种主流的方式：实现

Comparable

接口或者使用

Comparator

接口。这两种方式各有侧重，理解它们的区别和适用场景是关键。

1. 实现

Comparable

接口（定义对象的自然顺序）

当你的自定义类有一个“默认的”或“自然的”排序方式时，比如一个

Student

类，你可能希望它默认按照学号升序排列，那么就可以让

Student

类实现

Comparable

接口，并重写

compareTo

方法。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Student implements Comparable {
    String name;
    int studentId;
    int age;

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

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

    @Override
    public int compareTo(Student other) {
        // 默认按照学号升序排序
        return Integer.compare(this.studentId, other.studentId);
    }
}

public class ComparableExample {
    public static void main(String[] args) {
        List students = new ArrayList<>();
        students.add(new Student("Zhang San", 103, 20));
        students.add(new Student("Li Si", 101, 22));
        students.add(new Student("Wang Wu", 102, 21));

        System.out.println("原始学生列表: " + students);

        Collections.sort(students); // 使用Student的自然顺序（学号）排序

        System.out.println("按学号排序后: " + students);
        // 输出: [Student{name='Li Si', studentId=101, age=22}, Student{name='Wang Wu', studentId=102, age=21}, Student{name='Zhang San', studentId=103, age=20}]
    }
}

这种方式的好处是，一旦实现了

Comparable

，任何接受

Comparable

类型进行排序的方法（比如

Collections.sort(List)

或

Arrays.sort(Object[])

）都可以直接使用。

2. 使用

Comparator

接口（提供多种排序方式或外部排序）

起航点卡销售系统

欢迎使用“起航点卡销售系统”销售程序：一、系统优势 1、售卡系统采取了会员与非会员相结合的销售方法，客户无需注册即可购卡，亦可注册会员购卡。 2、购卡速度快，整个购卡或过程只需二步即可取卡，让客户感受超快的取卡方式！ 3、批量加卡功能。 4、取卡方式：网上支付，即时取卡，30秒可完成交易。 5、加密方式：MD5 32位不可倒推加密 6、防止跨站

下载

当你的对象没有自然顺序，或者你需要根据不同的业务场景提供多种排序方式时，

Comparator

就派上用场了。你可以创建多个

Comparator

实现，每个实现定义一种特定的排序规则。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

// 假设Person类没有实现Comparable
class PersonComparator {
    String name;
    int age;

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

    public String getName() { return name; }
    public int getAge() { return age; }

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

public class ComparatorExample {
    public static void main(String[] args) {
        List people = new ArrayList<>();
        people.add(new PersonComparator("Alice", 30));
        people.add(new PersonComparator("Bob", 25));
        people.add(new PersonComparator("Charlie", 35));
        people.add(new PersonComparator("David", 25));

        System.out.println("原始人员列表: " + people);

        // 方式一：匿名内部类实现Comparator，按年龄降序
        Collections.sort(people, new Comparator() {
            @Override
            public int compare(PersonComparator p1, PersonComparator p2) {
                return Integer.compare(p2.age, p1.age); // p2.age - p1.age 实现降序
            }
        });
        System.out.println("按年龄降序后: " + people);

        // 方式二：Lambda表达式实现Comparator，按姓名升序
        Collections.sort(people, (p1, p2) -> p1.name.compareTo(p2.name));
        System.out.println("按姓名升序后: " + people);

        // 方式三：使用Comparator.comparing() 和 thenComparing() 链式调用，按年龄升序，年龄相同按姓名降序
        Collections.sort(people, Comparator.comparing(PersonComparator::getAge) // 先按年龄升序
                                        .thenComparing(PersonComparator::getName, Comparator.reverseOrder())); // 年龄相同，按姓名降序
        System.out.println("按年龄升序，姓名降序后: " + people);
        // 输出: [PersonComparator{name='David', age=25}, PersonComparator{name='Bob', age=25}, PersonComparator{name='Alice', age=30}, PersonComparator{name='Charlie', age=35}]
        // 注意David和Bob的顺序，因为David的字母序在B之后，所以降序后David在前。
    }
}

Java 8引入的

Comparator.comparing()

和

thenComparing()

方法链式调用，简直是神器，极大地提升了编写复杂排序逻辑的效率和可读性。我个人在处理多字段排序时，几乎都用这种方式，代码写出来清晰又优雅。

Collections.sort()的性能考量和注意事项有哪些？

使用

Collections.sort()

虽然方便，但作为开发者，我们还是需要对它的底层机制和潜在影响有所了解，这样才能更好地驾驭它，避免一些坑。

1. 性能（时间复杂度与空间复杂度）

Collections.sort()

在Java 7之后，其底层排序算法是TimSort。TimSort是一个混合的、稳定的排序算法，它结合了归并排序（Merge Sort）和插入排序（Insertion Sort）。

时间复杂度： 在平均和最坏情况下都是
```
O(n log n)
```
。这对于大多数排序任务来说都是非常高效的。即使是部分有序的列表，TimSort也能很好地利用这种有序性，表现出接近
```
O(n)
```
的性能。
空间复杂度：
```
O(n)
```
。TimSort需要额外的空间来存储临时数组，这在最坏情况下可能与输入列表的大小相同。这意味着如果你在排序一个包含百万级元素的列表，可能需要额外几兆甚至几十兆的内存。对于内存敏感的应用，这可能是一个需要考虑的因素。

2. 稳定性

TimSort是一个稳定的排序算法。这意味着如果列表中存在两个“相等”的元素（即它们的

compareTo

或

compare

方法返回0），它们在排序后的相对顺序会保持不变。这在某些业务场景下非常重要，比如你先按日期排序，再按金额排序，你希望相同日期的元素，其金额的相对顺序不变。

3. 对

null

元素的处理

这是个常见的陷阱。如果你的列表中包含

null

元素，并且你使用

Collections.sort(List)

（依赖自然顺序），那么在比较

null

时会抛出

NullPointerException

。因为

null

无法调用

compareTo

方法。

如果你使用自定义

Comparator

，你需要确保你的

Comparator

能够正确处理

null

。通常的做法是在

compare

方法中显式地检查

null

：

// 示例：处理null的Comparator
Collections.sort(myList, (o1, o2) -> {
    if (o1 == null && o2 == null) return 0;
    if (o1 == null) return -1; // null排在前面
    if (o2 == null) return 1;  // null排在后面
    // 正常比较逻辑
    return o1.someProperty.compareTo(o2.someProperty);
});

4. 列表的可修改性