List集合排序

柔光的暖阳◎ 2023-09-26 09:19 22阅读 0赞

Java中集合排序，在Java8之前，可以通过 Collections类的sort方法进行排序；Java8之后，新增 lambda和stream ，都增加了相关的排序方法，本文将整理下常见的三种排序方法。

分别是：

> 说明：排序字段出现null值 会报错。
> 
>  *  List 接口中的 sort 方法 --- 【操作原数据】
>  *  Stream 接口中的 sorted 方法 --- 【返回新List】
>  *  Collections.sort 工具类方法 --- 【操作原数据】

示例代码如下：

package com.example.common;
    
    import com.example.common.utils.ObjectUtil;
    import com.example.common.utils.java.UtilMisc;
    import lombok.extern.slf4j.Slf4j;
    import org.junit.runner.RunWith;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.*;
    import java.util.stream.Collectors;
    
    
    /**
     *
     *  Java中集合排序:
     *
     *      说明：排序字段出现null值 会报错。
     *
     *      List 接口中的 sort 方法       --- 【操作原数据】
     *      Stream 接口中的 sorted 方法   --- 【返回新List】
     *      Collections.sort 工具类方法   --- 【操作原数据】
     *
     */
    @Slf4j
    public class ListSortTest {
    
        /**
         * 初始化机构列表数据
         * @return
         */
        public List<Map<String,Object>> getInitList() {
    
            List<Map<String,Object>> list = new ArrayList<>();
    
            list.add(UtilMisc.toStringKeyMap("orgId","100006","seqNo","006","orgName","测试机构100006"));
            list.add(UtilMisc.toStringKeyMap("orgId","100005","seqNo","005","orgName","测试机构100005"));
            list.add(UtilMisc.toStringKeyMap("orgId","100001","seqNo","001","orgName","测试机构100001"));
            list.add(UtilMisc.toStringKeyMap("orgId","100002","seqNo","002","orgName","测试机构100002"));
            list.add(UtilMisc.toStringKeyMap("orgId","100004","seqNo","004","orgName","测试机构100004"));
            list.add(UtilMisc.toStringKeyMap("orgId","100003","seqNo","003","orgName","测试机构100003"));
            list.add(UtilMisc.toStringKeyMap("orgId","100021","seqNo","001","orgName","测试机构100021"));
            list.add(UtilMisc.toStringKeyMap("orgId","100020","seqNo","001","orgName","测试机构100020"));
            list.add(UtilMisc.toStringKeyMap("orgId","100015","seqNo","001","orgName","测试机构100015"));
            list.add(UtilMisc.toStringKeyMap("orgId","100014","seqNo","001","orgName","测试机构100014"));
            list.add(UtilMisc.toStringKeyMap("orgId","100013","seqNo","001","orgName","测试机构100013"));
            list.add(UtilMisc.toStringKeyMap("orgId","100012","seqNo","001","orgName","测试机构100012"));
            list.add(UtilMisc.toStringKeyMap("orgId","100011","seqNo","001","orgName","测试机构100011"));
    
            return list;
        }
    
        /**
         * List接口中sort方法排序:
         *
         *      只根据序号排序（单字段排序）
         *
         *      说明：Comparator.comparing 中的参数值 不能是null，否则报错。
         *
         * @param list
         */
        public void listSortTestBySeqNo (List<Map<String,Object>> list) {
    
            list.sort(Comparator.comparing(map -> (String)map.get("seqNo")));
        }
    
        /**
         * List接口中sort方法排序:
         *
         *      根据序号、机构号排序 （多字段排序）
         *
         *      说明：seqNo 值相同时，才会根据orgId排序
         *
         * @param list
         */
        public void listSortTestBySeqNoAndOrgId (List<Map<String,Object>> list) {
    
    
            // 序号排序
            Comparator<Map<String,Object>> comparator1 = Comparator.comparing(map -> (String)map.get("seqNo"));
            // 机构号排序
            Comparator<Map<String,Object>> comparator2 = Comparator.comparing(map -> (String)map.get("orgId"));
    
            // 根据双字段排序，默认是正序
            list.sort(comparator1.thenComparing(comparator2));
        }
    
        /**
         * Collections.sort 方法排序:
         *
         *      只根据序号排序（单字段排序）
         *
         * @param list
         */
        public void collectionsSortTestBySeqNo (List<Map<String,Object>> list) {
    
            // 写法1：
            Collections.sort(list,Comparator.comparing(map -> (String)map.get("seqNo")));
    
            // 写法2：
            Collections.sort(list, new Comparator<Map<String, Object>>() {
                @Override
                public int compare(Map<String, Object> map1, Map<String, Object> map2) {
                    String seqNo1 = (String) map1.get("seqNo");
                    String seqNo2 = (String) map2.get("seqNo");
                    if (!Objects.equals(seqNo1,seqNo2)) {
                        return seqNo1.compareTo(seqNo2);
                    }
                    return 0;
                }
            });
    
    
    
        }
    
        /**
         * Collections.sort 方法排序:
         *
         *      说明：seqNo 值相同时，才会根据orgId排序
         *
         *      根据序号、机构号排序 （多字段排序）
         *
         * @param list
         */
        public void collectionsSortTestBySeqNoAndOrgId (List<Map<String,Object>> list) {
    
    
            // 序号排序
            Comparator<Map<String,Object>> comparator1 = Comparator.comparing(map -> (String)map.get("seqNo"));
            // 机构号排序
            Comparator<Map<String,Object>> comparator2 = Comparator.comparing(map -> (String)map.get("orgId"));
    
            // 根据双字段排序，默认是正序
    
            // 写法1：
    //        Collections.sort(list,comparator1.thenComparing(comparator2));
    
            // 写法2：
            Collections.sort(list, new Comparator<Map<String, Object>>() {
                @Override
                public int compare(Map<String, Object> map1, Map<String, Object> map2) {
                    String seqNo1 = (String) map1.get("seqNo");
                    String seqNo2 = (String) map2.get("seqNo");
                    String orgId1 = (String) map1.get("orgId");
                    String orgId2 = (String) map2.get("orgId");
                    if (seqNo1 != null && seqNo2 != null && !Objects.equals(seqNo1,seqNo2)) {
                        return seqNo1.compareTo(seqNo2);
                    }
    
                    if (orgId1 != null && orgId2 != null && !Objects.equals(orgId1,orgId2)) {
                        return orgId1.compareTo(orgId2);
                    }
    
                    return 0;
                }
            });
        }
    
    
        /**
         * stream.sort 方法排序:
         *
         *      只根据序号排序（单字段排序）
         *
         * @param list
         */
        public List<Map<String,Object>> streamSortTestBySeqNo (List<Map<String,Object>> list) {
    
            // 写法1：
            List<Map<String, Object>> collect = list.stream().sorted(new Comparator<Map<String, Object>>() {
                @Override
                public int compare(Map<String, Object> map1, Map<String, Object> map2) {
                    String seqNo1 = (String) map1.get("seqNo");
                    String seqNo2 = (String) map2.get("seqNo");
                    if (!Objects.equals(seqNo1, seqNo2)) {
                        return seqNo1.compareTo(seqNo2);
                    }
                    return 0;
                }
            }).collect(Collectors.toList());
    
    
            return collect;
        }
    
        /**
         * stream.sort 方法排序:
         *
         *      根据序号、机构号排序 （多字段排序）
         *
         * @param list
         */
        public List<Map<String,Object>> streamSortTestBySeqNoAndOrgId (List<Map<String,Object>> list) {
    
            // 写法1：
            List<Map<String, Object>> collect = list.stream().sorted(new Comparator<Map<String, Object>>() {
                @Override
                public int compare(Map<String, Object> map1, Map<String, Object> map2) {
                    String seqNo1 = (String) map1.get("seqNo");
                    String seqNo2 = (String) map2.get("seqNo");
                    String orgId1 = (String) map1.get("orgId");
                    String orgId2 = (String) map2.get("orgId");
                    if (seqNo1 != null && seqNo2 != null && !Objects.equals(seqNo1,seqNo2)) {
                        return seqNo1.compareTo(seqNo2);
                    }
    
                    if (orgId1 != null && orgId2 != null && !Objects.equals(orgId1,orgId2)) {
                        return orgId1.compareTo(orgId2);
                    }
    
                    return 0;
                }
            }).collect(Collectors.toList());
    
    
            return collect;
        }
    
    
    
    
        public static void main(String[] args) {
            ListSortTest sortTest = new ListSortTest();
            List<Map<String, Object>> list = sortTest.getInitList();
    
            List<Map<String, Object>> newList = null;
    
            System.out.println(" --------------------------- 排序前  -----------------------------------");
            sortTest.printlnList(list);
    
            // 单字段排序
    //        sortTest.listSortTestBySeqNo(list);
    
            // 多字段排序
    //        sortTest.listSortTestBySeqNoAndOrgId(list);
    //        sortTest.collectionsSortTestBySeqNoAndOrgId(list);
    
            newList = sortTest.streamSortTestBySeqNoAndOrgId(list);
    
            if (newList != null) {
                System.out.println(" --------------------------- 排序后newList  -----------------------------------");
                sortTest.printlnList(newList);
            }
    
            System.out.println(" --------------------------- 排序后list  -----------------------------------");
            sortTest.printlnList(list);
    
        }
    
    
        /**
         * 打印list数据
         * @param list
         */
        public void printlnList(List<Map<String, Object>> list) {
            for (Map<String, Object> map : list) {
                System.out.println(map);
            }
        }
    
    }