JDK1.8优雅的集合排序(集合的排序)

最新推荐文章于 2023-06-28 16:16:26 发布

一个正在学习前端的爪哇工程师

最新推荐文章于 2023-06-28 16:16:26 发布

阅读量5.5k

点赞数 1

分类专栏：集合排序 java基础文章标签：集合

本文链接：https://blog.csdn.net/mqs1990/article/details/109287588

版权

java基础同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

集合排序

1 篇文章 0 订阅

订阅专栏

集合的排序order，就是按照某个固定的规则进行排序，可能只是按照某个字段进行排序，也可能按照某几个字段进行排序已达到某种业务需求

比如我以前做过一个需求，一个分页列表数据的展示
但是这些数据的需要调用三个不同的接口进行查询，然后拼接在一起，展示。因为数据源来源于多个接口(也就是多个库)，所以处理的方式：分别调用这个三个接口，把这三个接口返回的数据转化成同一个对象，然后这些集合对象进行拼接，再按照排序规则进行排序并对最终的集合进行截取，获取当前页的数据集即可。
备注：如果调用的接口响应很慢，但是接口无法提效(比如接口是来源于第三方)，可以采用这个三个接口同时去请求(并行去处理),假如每个接口的响应时间是1.2s，串行的响应时间就是1.2+1.2+1.2=3.6s，并行去处理的话，获取这三个接口的响应时间仍旧是1.2s。

本博客主要讲了简单对象的排序和复杂对象的排序。
简单对象的排序比如Integer、String、BigDecimal等，本文以Integer为例。
复杂对象的排序比如我们自定义的dto

1、环境准备工作
编码工具(idea) + JDK1.8

2、代码

2.1、创建DTO

/**
 * Date: 2020/10/22
 * Time: 下午19:25
 *
 * @author 深思熟虑
 */

public class StudentDTO {

    /**
     * 主键
     */
    private Integer id;

    /**
     * 姓名
     */
    private String name;


    /**
     * 英语分数
     */
    private BigDecimal englishScore;

    /**
     * 数学分数
     */
    private BigDecimal mathScore;

    /**
     * 语文成绩
     */
    private BigDecimal chinaScore;

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public BigDecimal getEnglishScore() {
        return englishScore;
    }

    public BigDecimal getMathScore() {
        return mathScore;
    }

    public BigDecimal getChinaScore() {
        return chinaScore;
    }

    public void setId(Integer id) {
        this.id = id;
    }

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

    public void setEnglishScore(BigDecimal englishScore) {
        this.englishScore = englishScore;
    }

    public void setMathScore(BigDecimal mathScore) {
        this.mathScore = mathScore;
    }

    public void setChinaScore(BigDecimal chinaScore) {
        this.chinaScore = chinaScore;
    }

    @Override
    public String toString() {
        return "StudentDTO{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", englishScore=" + englishScore +
                ", mathScore=" + mathScore +
                ", chinaScore=" + chinaScore +
                '}';
    }

2.2、排序：

/**
 * Date: 2020/10/22
 * Time: 下午11:23
 *
 * @author 深思熟虑
 */
public class SortDemo {

    public static void main(String[] args) {

        /**
         * 以Integer为demo，进行排序
         * 排序的list中，如果有的元素为null,则会报错NPE(空指针)
         */
        sortInteger();

        /**
         * 以Integer为demo，进行排序
         * list中元素为null的排序code如下
         * 注：null排在最前后者最后面两种方式
         */
        sortIntegerWithNUll();

        /**
         * 复杂对象的排序，为null会报空指针异常
         * 集合中含有null的问题可以参考 sortIntegerWithNUll方法，省略
         */
        sortObj();

        /**
         * 复杂排序:多条件排序
         * 场景：先按照语文成绩排序，如果语文成绩一样，再按照数学成绩排序
         */
        complexSort();

        /**
         * 自定义排序
         */
        customizeSort();

    }

    /**
     * 基本类型的排序
     * 对于integer的排序 写法1, Comparator.comparing 与Comparator.comparingInt，两者可以互相代替
     * 对于integer的排序 写法1，Comparator.comparing 与Comparator.comparingInt，两者不可以互相代替
     */
    private static void sortInteger() {
        /**
         * Integer 排序
         */
        List<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(9);
        list.add(15);
        list.add(5);
        list.add(3);
        // 正序 写法1
        list.sort(Comparator.comparing(Integer::intValue));
        System.out.println("=======正序 写法 1======");
        list.forEach(System.out::println);

        // 正序 写法2(naturalOrder 自然排序就是正序)
        // Comparator.comparing 与Comparator.comparingInt，两者可以互相代替
        list.sort(Comparator.comparing(Integer::intValue, Comparator.naturalOrder()));
        System.out.println("=======正序 写法 2======");
        list.forEach(System.out::println);

        // 倒序  reverseOrder倒序
        // Comparator.comparing 与Comparator.comparingInt，两者不可以互相代替
        list.sort(Comparator.comparing(Integer::intValue, Comparator.reverseOrder()));
        System.out.println("=======倒序======");
        list.forEach(System.out::println);


    }

    private static void sortIntegerWithNUll() {
        /**
         * Integer 排序
         */
        List<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(null);
        list.add(9);
        list.add(15);
        list.add(null);
        list.add(5);
        list.add(3);

        System.out.println("=======集合中有null,原始数据======");
        list.forEach(System.out::println);

        // null 排最前面 正序
        list.sort(Comparator.nullsFirst(Comparator.comparing(Integer::intValue)));
        System.out.println("=======null 排最前面 正序======");
        list.forEach(System.out::println);

        list.sort(Comparator.nullsFirst(Comparator.comparing(Integer::intValue, Comparator.naturalOrder())));
        list.sort(Comparator.nullsFirst(Comparator.comparingInt(Integer::intValue)));

        // null 排最后面 正序
        list.sort(Comparator.nullsLast(Comparator.comparing(Integer::intValue)));
        System.out.println("=======null 排最后面 正序======");
        list.forEach(System.out::println);

        list.sort(Comparator.nullsLast(Comparator.comparing(Integer::intValue, Comparator.naturalOrder())));
        list.sort(Comparator.nullsLast(Comparator.comparingInt(Integer::intValue)));

        // 倒序省略 。。。。

    }

    private static void sortObj() {
        List<StudentDTO> students = new ArrayList<>();

        System.out.println("==================按照学生的英语传成绩原始数据=========================");
        // 测试数据
        for (int i=0; i < 5; i++) {
            StudentDTO studentDTO = new StudentDTO();
            studentDTO.setId(i);
            studentDTO.setName("张三" + 1);
            studentDTO.setChinaScore(BigDecimal.valueOf(Math.random()).multiply(BigDecimal.valueOf(100)).setScale(2, RoundingMode.HALF_UP));
            studentDTO.setEnglishScore(BigDecimal.valueOf(Math.random()).multiply(BigDecimal.valueOf(100)).setScale(2, RoundingMode.HALF_UP));
            studentDTO.setMathScore(BigDecimal.valueOf(Math.random()).multiply(BigDecimal.valueOf(100)).setScale(2, RoundingMode.HALF_UP));
            students.add(studentDTO);
            System.out.println(studentDTO);
        }

        /**
         * 按照学生的英语传成绩进行正序排序
         * 不加这个参数Comparator.naturalOrder()默认是正序
         */
        students.sort(Comparator.comparing(StudentDTO::getEnglishScore, Comparator.naturalOrder()));

        System.out.println("==================按照学生的英语传成绩进行正序排序=========================");

        students.forEach(System.out::println);

        /**
         * 按照学生的英语传成绩进行倒序排序
         */
        students.sort(Comparator.comparing(StudentDTO::getEnglishScore, Comparator.reverseOrder()));

        System.out.println("==================按照学生的英语传成绩进行倒序排序=========================");

        students.forEach(System.out::println);

    }

    private static void complexSort() {
        System.out.println("==========多条件排序=============");
        List<StudentDTO> students = new ArrayList<>();

        StudentDTO studentDTO1 = new StudentDTO();
        studentDTO1.setId(1);
        studentDTO1.setName("小明");
        studentDTO1.setMathScore(BigDecimal.valueOf(90));
        studentDTO1.setChinaScore(BigDecimal.valueOf(87.5));
        studentDTO1.setEnglishScore(BigDecimal.valueOf(84));
        students.add(studentDTO1);

        StudentDTO studentDTO2 = new StudentDTO();
        studentDTO2.setId(1);
        studentDTO2.setName("小花");
        studentDTO2.setMathScore(BigDecimal.valueOf(90));
        studentDTO2.setChinaScore(BigDecimal.valueOf(97));
        studentDTO2.setEnglishScore(BigDecimal.valueOf(88));
        students.add(studentDTO2);

        StudentDTO studentDTO3 = new StudentDTO();
        studentDTO3.setId(1);
        studentDTO3.setName("小刘");
        studentDTO3.setMathScore(BigDecimal.valueOf(93));
        studentDTO3.setChinaScore(BigDecimal.valueOf(87.5));
        studentDTO3.setEnglishScore(BigDecimal.valueOf(88));
        students.add(studentDTO3);

        System.out.println("==========多条件排序:原数据=============");
        students.forEach(System.out::println);

        System.out.println("==========多条件排序:排序之后数据=============");
        System.out.println("==========按照语文成绩排名，语文成绩一样，再按照数学成绩排名=============");
        students.sort(Comparator.comparing(StudentDTO::getChinaScore, Comparator.reverseOrder())
                .thenComparing(StudentDTO::getMathScore, Comparator.reverseOrder()));
        students.forEach(System.out::println);
    }

    /**
     * 自定义排序
     * 比如 学生按照 语文成绩进行排名，如果一样的话，再按照数学成绩排名
     * 比如 学生 按照总的成绩进行排序，如果总的成绩一样，按照语文成绩排序
     * 以上两种场景的排序，都是比较复杂的排序，需要自定义排序
     */
    private static void customizeSort() {
        System.out.println("==========多条件排序=============");
        List<StudentDTO> students = new ArrayList<>();

        StudentDTO studentDTO1 = new StudentDTO();
        studentDTO1.setId(1);
        studentDTO1.setName("小明");
        studentDTO1.setMathScore(BigDecimal.valueOf(90));
        studentDTO1.setChinaScore(BigDecimal.valueOf(87.5));
        studentDTO1.setEnglishScore(BigDecimal.valueOf(84));
        students.add(studentDTO1);

        StudentDTO studentDTO2 = new StudentDTO();
        studentDTO2.setId(1);
        studentDTO2.setName("小花");
        studentDTO2.setMathScore(BigDecimal.valueOf(90));
        studentDTO2.setChinaScore(BigDecimal.valueOf(97));
        studentDTO2.setEnglishScore(BigDecimal.valueOf(88));
        students.add(studentDTO2);

        StudentDTO studentDTO3 = new StudentDTO();
        studentDTO3.setId(1);
        studentDTO3.setName("小刘");
        studentDTO3.setMathScore(BigDecimal.valueOf(93));
        studentDTO3.setChinaScore(BigDecimal.valueOf(87.5));
        studentDTO3.setEnglishScore(BigDecimal.valueOf(88));
        students.add(studentDTO3);

        System.out.println("==========多条件排序:原数据=============");
        students.forEach(System.out::println);
    }