Java：详解List集合的排序功能

概述

List集合有两大排序方式，分别为自然排序和自定义排序。
使用自然排序，需要元素类达到某种要求。
使用自定义排序，就是在需要排序的时候才传入排序规则。

自然排序

• 自然排序是 Collections.sort 方法，只带一个参数，参数为List集合。
• 默认能直接使用自然排序的，有基本数据类型的包装类型、String类型等等。
• 数字类型的自然排序顺序固定为从小到大。

public static void main(String[] args) {
    List<Integer> list = new ArrayList();
    list.add(2);
    list.add(1);
    list.add(3);
    Collections.sort(list);
    System.out.println(list);
    // 输出：[1, 2, 3]
}

• 为什么那些类型能用于自然排序？因为它们都有一个特点，就是实现了 Comparable<E> 接口的 compareTo 方法。
• 该方法的使用意义是让自身对象与另一个对象进行某方面的比较大小，用前者减去后者，返回正数则认为是前者的更大，返回负数则认为前者的更小。

下面我们来自定义一个类，让它实现该接口的方法。

public class Person implements Comparable {
    public Person(int age) { this.age = age; }

    private int age;

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

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

    @Override
    public int compareTo(Object o) {
        return age - ((Person) o).getAge();
    }
}

尝试使用一下：

public static void main(String[] args) {
    List<Person> list = new ArrayList();
    list.add(new Person(18));
    list.add(new Person(30));
    list.add(new Person(25));

    Collections.sort(list);

    System.out.println(list);
    // 输出：[Person{age=18}, Person{age=25}, Person{age=30}]
}

自定义排序

先重新定义一下Person类，让Person类本身与排序无关。

public class Person {
    public Person(int age) { this.age = age; }

    private int age;

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

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

• 自定义排序同样也是 Collections.sort 方法，但是要多一个参数，该参数要实现 Comparator<E> 接口的 compare 方法。
• 自定义排序的比较与自然排序的比较，它们的意义是相似。

为了方便，直接使用匿名内部类：

public static void main(String[] args) {
    List<Person> list = new ArrayList();
    list.add(new Person(18));
    list.add(new Person(30));
    list.add(new Person(25));
    
    Collections.sort(list, new Comparator<Person>() {
        @Override
        public int compare(Person o1, Person o2) {
            return o1.getAge() - o2.getAge();
        }
    });
    
    System.out.println(list);
    // 输出：[Person{age=18}, Person{age=25}, Person{age=30}]
}

然后可以简单化为Lambda表达式：

public static void main(String[] args) {
    List<Person> list = new ArrayList();
    list.add(new Person(18));
    list.add(new Person(30));
    list.add(new Person(25));

    Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge());

    System.out.println(list);
    // 输出：[Person{age=18}, Person{age=25}, Person{age=30}]
}

还能继续精简为方法引用：

public static void main(String[] args) {
    List<Person> list = new ArrayList();
    list.add(new Person(18));
    list.add(new Person(30));
    list.add(new Person(25));

    Collections.sort(list, Comparator.comparingInt(Person::getAge));

    System.out.println(list);
    // 输出：[Person{age=18}, Person{age=25}, Person{age=30}]
}