掌握这5种排序写法，便可应对任意场景

推荐：前牛客网明星算法讲师——左程云亲授：算法与数据结构大厂面试最优解（附程序员代码面试指南第2版）

排序在日常中用到的挺多的，总的来说排序就下面 5 种，其他的都是下面的变种，掌握之后，其他各种排序都可应对自如。

1、普通类型升序

如下代码，列举了 String、Integer 类型集合升序，其他类型：Long、Double、Float、Byte 类似

//正序
@Test
public void test1() {
    //String类型升序
    List<String> stringList = Arrays.asList("5", "2", "4", "3", "1");
    //排序后
    List<String> stringListSorted = stringList.stream().
            sorted(String::compareTo).
            collect(Collectors.toList());
    stringListSorted.forEach(System.out::println);

    System.out.println("----------------------");

    //Integer类型升序
    List<Integer> intList = Arrays.asList(5, 2, 4, 3, 1);
    //排序后
    List<Integer> intListSorted = intList.stream().
            sorted(Integer::compareTo).
            collect(Collectors.toList());
    intListSorted.forEach(System.out::println);
}

输出

1
2
3
4
5
----------------------
1
2
3
4
5

2、普通类型降序

如下代码，列举了 String、Integer 类型集合降序，其他类型：Long、Double、Float、Byte 类似

//降序
@Test
public void test2() {
    //String类型降序
    List<String> stringList = Arrays.asList("5", "2", "4", "3", "1");
    //排序后
    List<String> stringListSorted = stringList.stream().
        sorted(String::compareTo).
        sorted(Comparator.reverseOrder()).
        collect(Collectors.toList());
    stringListSorted.forEach(System.out::println);

    System.out.println("----------------------");

    //Integer类型降序
    List<Integer> intList = Arrays.asList(5, 2, 4, 3, 1);
    //排序后
    List<Integer> intListSorted = intList.stream().
        sorted(Integer::compareTo).
        sorted(Comparator.reverseOrder()).
        collect(Collectors.toList());
    intListSorted.forEach(System.out::println);
}

输出

5
4
3
2
1
----------------------
5
4
3
2
1

3、Java 对象单字段升序

按照用户年龄升序排序，先来个用户类

public static class User{
    private String name;
    private Integer age;

    public User(String name, Integer age) {
        this.name = name;
        this.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;
    }

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

按照 age 升序，代码如下

@Test
public void test3(){
    List<User> userList = Arrays.asList(
        new User("1001",30),
        new User("1002",20),
        new User("1003",40),
        new User("1004",20));
    List<User> userListSorted = userList.stream().
        sorted(Comparator.comparing(User::getAge)).
        collect(Collectors.toList());
    userListSorted.stream().forEach(System.out::println);
}

运行输出

User{name='1002', age=20}
User{name='1004', age=20}
User{name='1001', age=30}
User{name='1003', age=40}

5、Java 对象单字段降序

按照 age 降序，代码如下

@Test
public void test4(){
    List<User> userList = Arrays.asList(
            new User("1001",30),
            new User("1002",20),
            new User("1003",40),
            new User("1004",20));
    List<User> userListSorted = userList.stream().
            sorted(Comparator.comparing(User::getAge).reversed()).
            collect(Collectors.toList());
    userListSorted.stream().forEach(System.out::println);
}

运行输出

User{name='1003', age=40}
User{name='1001', age=30}
User{name='1002', age=20}
User{name='1004', age=20}

6、Java 对象多字段排序

age 升序，name 降序

@Test
public void test5() {
    List<User> userList = Arrays.asList(
            new User("1001", 30),
            new User("1002", 20),
            new User("1003", 40),
            new User("1004", 20));
    List<User> userListSorted = userList.stream().
            sorted(Comparator.comparing(User::getAge).
                    thenComparing(Comparator.comparing(User::getName).reversed())).
            collect(Collectors.toList());
    userListSorted.stream().forEach(System.out::println);
}

运行输出

User{name='1004', age=20}
User{name='1002', age=20}
User{name='1001', age=30}
User{name='1003', age=40}

7、完整代码

import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class SortTest {
    //正序
    @Test
    public void test1() {
        //String类型升序
        List<String> stringList = Arrays.asList("5", "2", "4", "3", "1");
        //排序后
        List<String> stringListSorted = stringList.stream().
                sorted(String::compareTo).
                collect(Collectors.toList());
        stringListSorted.forEach(System.out::println);

        System.out.println("----------------------");

        //Integer类型升序
        List<Integer> intList = Arrays.asList(5, 2, 4, 3, 1);
        //排序后
        List<Integer> intListSorted = intList.stream().
                sorted(Integer::compareTo).
                collect(Collectors.toList());
        intListSorted.forEach(System.out::println);
    }

    //降序
    @Test
    public void test2() {
        //String类型降序
        List<String> stringList = Arrays.asList("5", "2", "4", "3", "1");
        //排序后
        List<String> stringListSorted = stringList.stream().
                sorted(String::compareTo).
                sorted(Comparator.reverseOrder()).
                collect(Collectors.toList());
        stringListSorted.forEach(System.out::println);

        System.out.println("----------------------");

        //Integer类型降序
        List<Integer> intList = Arrays.asList(5, 2, 4, 3, 1);
        //排序后
        List<Integer> intListSorted = intList.stream().
                sorted(Integer::compareTo).
                sorted(Comparator.reverseOrder()).
                collect(Collectors.toList());
        intListSorted.forEach(System.out::println);
    }

    //age 升序
    @Test
    public void test3() {
        List<User> userList = Arrays.asList(
                new User("1001", 30),
                new User("1002", 20),
                new User("1003", 40),
                new User("1004", 20));
        List<User> userListSorted = userList.stream().
                sorted(Comparator.comparing(User::getAge)).
                collect(Collectors.toList());
        userListSorted.stream().forEach(System.out::println);
    }

    //age 降序
    @Test
    public void test4() {
        List<User> userList = Arrays.asList(
                new User("1001", 30),
                new User("1002", 20),
                new User("1003", 40),
                new User("1004", 20));
        List<User> userListSorted = userList.stream().
                sorted(Comparator.comparing(User::getAge).reversed()).
                collect(Collectors.toList());
        userListSorted.stream().forEach(System.out::println);
    }

    //age升序 name降序
    @Test
    public void test5() {
        List<User> userList = Arrays.asList(
                new User("1001", 30),
                new User("1002", 20),
                new User("1003", 40),
                new User("1004", 20));
        List<User> userListSorted = userList.stream().
                sorted(Comparator.comparing(User::getAge).
                        thenComparing(Comparator.comparing(User::getName).reversed())).
                collect(Collectors.toList());
        userListSorted.stream().forEach(System.out::println);
    }


    public static class User {
        private String name;
        private Integer age;

        public User(String name, Integer age) {
            this.name = name;
            this.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;
        }

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