List集合排序

        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);
        }
    }

}