JDK8 list＜object＞转map＜string,map＜string,list＜object＞＞＞并排序 示例

先上测试代码：

package com.lalala.test;

import lombok.Data;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 类描述：
 *
 * @ClassName test
 * @Description TODO
 * @Author lalala
 * @Date 2023/8/18 11:12
 * @Version 1.0
 */
public class test {
    @Data
    static class Obj{
        public Obj(String name, String sortNo, String dirName, String levelSort, String levelName) {
            this.name = name;
            this.sortNo = sortNo;
            this.dirName = dirName;
            this.levelSort = levelSort;
            this.levelName = levelName;
        }
        //序号
        String sortNo;
        //目录名称
        String dirName;
        //级次序号
        String levelSort;
        //级次名称
        String levelName;
        //名称
        String name;
    }

    public static void main(String[] args) {
        List<Obj> list = new ArrayList<>();
        list.add(new Obj("name","1","d1","1","级次"));
        list.add(new Obj("name","5","d2","3","级次"));
        list.add(new Obj("name","2","d2","3","级次"));
        list.add(new Obj("name","5","d1","2","级次"));
        list.add(new Obj("name","2","d1","1","级次"));
        list.add(new Obj("name","3","d1","3","级次"));
        list.add(new Obj("name","1","d2","2","级次"));
        list.add(new Obj("name","4","d1","2","级次"));
        list.add(new Obj("name","4","d2","1","级次"));
        list.add(new Obj("name","3","d2","4","级次"));
        LinkedHashMap<String, LinkedHashMap<String, List<Obj>>> collect = list.stream()
                //1.1按照目录名称降序排序 默认升序 reversed()降序
                .sorted(Comparator.comparing(Obj::getDirName).reversed())
                .collect(
                        //1.2按照目录名称分组
                        Collectors.groupingBy(
                                dirOfObj -> dirOfObj.getDirName(),
                                //方式一 分组+排序
                                LinkedHashMap::new,
                                Collectors.collectingAndThen(
                                        //2.1按照级次序号+级次名称分组
                                        Collectors.groupingBy(
                                                levelOfObj -> levelOfObj.getLevelSort() + "_" + levelOfObj.getLevelName(),
                                                LinkedHashMap::new,
                                                Collectors.collectingAndThen(
                                                        Collectors.toList(),
                                                        //3.按照序号排序
                                                        tolist -> {
                                                            tolist.sort(Comparator.comparing(Obj::getSortNo));
                                                            return tolist;
                                                        }
                                                )
                                        ),
                                        //2.2按照级次序号排序
                                        map -> {
                                            map = map.entrySet().stream().sorted(
                                                    (o1, o2) -> o1.getKey().split("_")[0].compareTo(o2.getKey().split("_")[0])
                                            ).collect(Collectors.toMap(
                                                    Map.Entry::getKey,
                                                    Map.Entry::getValue,
                                                    (oldVal, newVal) -> oldVal,
                                                    LinkedHashMap::new
                                            ));
                                            return map;
                                        }
                                )
                                //方式二 分组不带排序
//                                    Collectors.groupingBy(
//                                            levelOfObj -> levelOfObj.getLevelSort() + "_" + levelOfObj.getLevelName(),
//                                            LinkedHashMap::new,
//                                            Collectors.collectingAndThen(
//                                                    Collectors.toList(),
//                                                    tolist -> {
//                                                        tolist.sort(Comparator.comparing(Obj::getSortNo));
//                                                        return tolist;
//                                                    }
//                                            )
//                                    )
                        )
                );
        System.out.println(list);
        System.out.println(collect);

    }
}

 输出截图

1.初始list

2.转为map

Map<key1,Map<key2,List<Obj>>>

key1：目录名分组 --按照目录名称降序排序

key2：级次序号+级次名称分组 --按照级次序号升序排序

list<Obj>分组后集合数据 --按照序号升序排序