Java 对象List集合排序的5种方式_java list 对象排序

目标明确

排序对象类

public class Student{

    private String name;

    private Integer age;

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

方式一：排序对象类实现Comparable接口的compareTo方法

Student类

public class Student implements Comparable<Student>{

    private String name;

    private Integer age;

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    /**
     * 需要实现的方法，实现升序排序，降序请反写
     * this表示当前的对象
     * @param o 比较时传入的对象
     * @return
     */
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

Main

public class Test {


    public static void main(String[] args) {

        //数据准备
        List<Student> list = new ArrayList<>();
        list.add(new Student("小明",1));
        list.add(new Student("小红",4));
        list.add(new Student("小刚",3));
        list.add(new Student("小鸡",5));
        list.add(new Student("小狗",2));


        //使用Collections集合工具类进行排序
        Collections.sort(list);

        for (Student student : list) {
            System.out.println(student);
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

compareTo方法实际上是一个比较大小的方法，只要是排序，我们必须用到比较，若果是简单的整数数组排序，我们只需要用 > 、 < 等进行比较，但是对于对象来说，Collections集合工具类在进行排序时，每次比较，都是调用的我们实现的compareTo方法，this表示当前对象，o表示要进行比较的传入对象，返回是一个int类型的整数

• 返回值>0：表示当前对象比传入对象大（年龄）
• 返回值=0：表示当前对象和传入对象一样大（年龄）
• 返回值<0：表示当前对象比传入对象小（年龄）

排序结果：

Student{name='小明', age=1}
Student{name='小狗', age=2}
Student{name='小刚', age=3}
Student{name='小红', age=4}
Student{name='小鸡', age=5}

Process finished with exit code 
1
2
3
4
5
6
7

方式二：使用Comparator接口自定义行为

使用方式一我们必须在Student类上面进行修改，这显然不是最好的办法，如果我们不想按年龄排序，想要按照姓名排序，或者我们有一个方法需要按照年龄，另一个方法需要按照姓名，那么重写compareTo方法显然就没法完成我们的目标了，Collections的重载sort方法可以允许我们在排序对象外部自定义一个比较器（Comparator接口的实现类），因为我们仅需要实现compare（）方法（实际上Comparator接口是一个函数式接口，无伤大雅最后解释，想了解的看最后），没必要在定义一个类，我们直接使用匿名内部类的方式。

此时的Student类我们不用进行任何改写，和最原始的一样即可

Main

public class Test {


    public static void main(String[] args) {

        //数据准备
        List<Student> list = new ArrayList<>();
        list.add(new Student("小明",1));
        list.add(new Student("小红",4));
        list.add(new Student("小刚",3));
        list.add(new Student("小鸡",5));
        list.add(new Student("小狗",2));


        //使用Collections集合工具类进行排序
        Collections.sort(list, new Comparator<Student>() {

            @Override
            public int compare(Student o1, Student o2) {
                //升序排序，降序反写
                return o1.getAge()-o2.getAge();
            }

        });

        for (Student student : list) {
            System.out.println(student);
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

排序结果：

Student{name='小明', age=1}
Student{name='小狗', age=2}
Student{name='小刚', age=3}
Student{name='小红', age=4}
Student{name='小鸡', age=5}

Process finished with exit code 0
1
2
3
4
5
6
7

我们也可以使用List的sort方法（这是List接口的一个默认方法）源码如下：

@SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }
1
2
3
4
5
6
7
8
9
10

我们也需要传入一个Comparator，此处使用匿名类的形式，代码如下：

public static void main(String[] args) {

        //数据准备
        List<Student> list = new ArrayList<>();
        list.add(new Student("小明",1));
        list.add(new Student("小红",4));
        list.add(new Student("小刚",3));
        list.add(new Student("小鸡",5));
        list.add(new Student("小狗",2));


        list.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()-o2.getAge();
            }
        });

        for (Student student : list) {
            System.out.println(student);
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

方式三：Lambda表达式

方式二相比，只改变了一行代码
将

Collections.sort(list, new Comparator<Student>() {

            @Override
            public int compare(Student o1, Student o2) {
                //升序排序，降序反写
                return o1.getAge()-o2.getAge();
            }

        });
1
2
3
4
5
6
7
8
9

变为

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

或者使用list的sort方法：

将

 list.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()-o2.getAge();
            }
        });
1
2
3
4
5
6

变为：

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

方式四：使用方法引用进一步简化

上文方式三

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

可以变为：

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

使用List的sort方法时：

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

可以改为

list.sort(Comparator.comparingInt(Student::getAge));
1

方式五：使用Stream流

List<Student> students = list.stream().
                sorted((Comparator.comparingInt(Student::getAge)))
                .collect(Collectors.toList());
1
2
3

注：返回一个有序的List集合

关于Comparator接口

上文说Comparator接口是一个函数式接口，那么什么是函数式接口呢？

函数式接口就是只定义一个抽象方法的接口。
JDK1.8开始支持默认方法，即便这个接口拥有很多默认方法，只要接口只有一个抽象方法，那么这个接口就是函数式接口。
1
2

函数式接口常常用@FunctionInterface来标注，不是必须的，带有@FunctionInterface注解的接口如果不满足函数式接口（有多个抽象方法），编译器会返回提示信息，自己创建函数式接口时推荐使用。

end

---

个人公众号

我的个人公众号已经开通了，正在按计划建设中，以后的文章会第一时间发布在公众号中，同时也给大家准备了亿点学习资料，关注公众号后台发送：学习资料