树结构处理，list和tree互转

1、实体类

package com.iot.common.test.entity;
 
import lombok.Data;
 
import java.util.List;
 
/**
 * @description:
 * @author:zilong
 * @date:2023/9/8
 */
@Data
public class Node {
    //id
    private String id;
    //父节点id
    private String pId;
    //名称
    private String name;
    //编码
    private String code;
    //层级
    private String level;
    private List children;
 
    public Node(String id, String pId, String name, String code, String level) {
        this.id = id;
        this.pId = pId;
        this.name = name;
        this.code = code;
        this.level = level;
    }
 
 
    public Node() {
 
    }
}

2、工具类

package com.iot.common.util;
 
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.iot.common.test.entity.Node;
import lombok.SneakyThrows;
 
import java.lang.invoke.SerializedLambda;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.stream.Collectors;
 
/**
 * 树工具类
 */
 
public class TreeUtil {
 
 
    /**
     * 基础数据转树结构Map版本（速度比递归要快很多）
     *
     * @param sourceList  需转换的数据
     * @param getId       主键
     * @param getParentId 父id （父id必须和主键相同类型）
     * @param getChildren 子集
     * @param setChildren 子集
     * @return tree
     */
    public static  List listToTree(List sourceList, Function getId, Function getParentId,
                                            Function> getChildren, BiConsumer> setChildren) {
 
        Map oldMap = sourceList.stream().collect(Collectors.toMap(getId, T -> T));
        List treeList = new ArrayList<>();
        sourceList.forEach(tree -> {
            T parent = oldMap.get(getParentId.apply(tree));
            if (parent == null) {
                treeList.add(tree);
            } else {
                List ch = getChildren.apply(parent);
                if (ch == null) {
                    ch = new ArrayList<>();
                }
                ch.add(tree);
                setChildren.accept(parent, ch);
            }
        });
        return treeList;
    }
 
    /**
     * 树结构转父子排序列表且按父在前，子在后，进行排序。
     *
     * @param treeList    父子树列表（带有id、parentId和children的模型列表）
     * @param getId
     * @param getParentId
     * @param getChildren
     * @param setChildren
     * @param 
     * @param 
     * @return
     */
    public static  List treeListToSortList(List treeList, Function getId, Function getParentId,
                                                    Function> getChildren, BiConsumer> setChildren) {
        // 先整成树形结构
        List list = listToTree(treeList, getId, getParentId, getChildren, setChildren);
        List sortList = new ArrayList<>();
        tree2List(sortList, list.get(0), getChildren, setChildren);
        return sortList;
    }
 
    /**
     * 树结构转列表
     *
     * @param result      结果容器
     * @param t           树顶部元素
     * @param getChildren
     * @param 
     */
    private static  void tree2List(List result, T t, Function> getChildren, BiConsumer> setChildren) {
        //根据条件判断是否需要添加至列表
        result.add(t);
        List children = getChildren.apply(t);
        // 将children置成空
        setChildren.accept(t, null);
        //没有子级
        if (children == null || children.size() == 0) {
            return;
        }
        //存在子级，递归调用
        for (T child : children) {
            tree2List(result, child, getChildren, setChildren);
        }
    }
 
    /**
     * 基础数据集转树结构
     *
     * @param baseList      树结构的基础数据集
     * @param getIdFn       获取主键的函数
     * @param getParentIdFn 获取父节点的函数
     * @param getChildrenFn 获取子集的函数
     * @param            t
     * @param            r
     * @return t
     */
    @SneakyThrows
    public static  List treeOut(List baseList, Function getIdFn, Function getParentIdFn, SFunction getChildrenFn) {
        /*所有元素的Id*/
        List