Java中Collections.sort方法使用方法-java教程-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<String> 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<Integer> 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<Person> 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<Person>() {
            @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<T> list, Comparator<? super T> c)

登录后复制

是一个静态方法，属于

java.util.Collections

登录后复制

工具类。它接受一个

List

登录后复制

对象和一个可选的

Comparator

登录后复制

作为参数，然后对传入的

List

登录后复制

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

而

List.sort(Comparator<? super E> 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<Student>

登录后复制

接口，并重写

compareTo

登录后复制

方法。

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

class Student implements Comparable<Student> {
    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<Student> 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

登录后复制

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

启科网络PHP商城系统

启科网络商城系统由启科网络技术开发团队完全自主开发，使用国内最流行高效的PHP程序语言，并用小巧的MySql作为数据库服务器，并且使用Smarty引擎来分离网站程序与前端设计代码，让建立的网站可以自由制作个性化的页面。系统使用标签作为数据调用格式，网站前台开发人员只要简单学习系统标签功能和使用方法，将标签设置在制作的HTML模板中进行对网站数据、内容、信息等的调用，即可建设出美观、个性的网站。

查看详情

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

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<PersonComparator> 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<PersonComparator>() {
            @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. 列表的可修改性