Java树结构工具类

package com.ciih.chatedu.common.util;

import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import lombok.SneakyThrows;

import java.lang.invoke.SerializedLambda;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 树形工具类-函数版
 *
 * @author sunziwen
 */

public class TreeUtil {


    /**
     * Map版本（速度比递归要快很多）
     * listToTree
     *
     * @param target      需转换的数据
     * @param getId       主键
     * @param getParentId 父id （父id必须和主键相同类型）
     * @param getChildren 子集
     * @param setChildren 子集
     * @return tree
     */
    public static <T, R> List<T> listToTree(List<T> target, Function<T, R> getId, Function<T, R> getParentId,
                                            Function<T, List<T>> getChildren, BiConsumer<T, List<T>> setChildren) {

        Map<R, T> oldMap = target.stream().collect(Collectors.toMap(getId, T -> T));
        List<T> result = new ArrayList<>();
        target.forEach(tree -> {
            T parent = oldMap.get(getParentId.apply(tree));
            if (parent == null) {
                result.add(tree);
            } else {
                List<T> ch = getChildren.apply(parent);
                if (ch == null) {
                    ch = new ArrayList<>();
                }
                ch.add(tree);
                setChildren.accept(parent, ch);
            }
        });
        return result;
    }

    /**
     * 树列表转父子排序列表且按父在前，子在后，进行排序。
     *
     * @param target 父子树列表（带有id、parentId和children的模型列表）
     * @param getId
     * @param getParentId
     * @param getChildren
     * @param setChildren
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> List<T> treeListToSortList(List<T> target, Function<T, R> getId, Function<T, R> getParentId,
                                                  Function<T, List<T>> getChildren, BiConsumer<T, List<T>> setChildren) {
        // 先整成树形结构
        List<T> list = listToTree(target, getId, getParentId, getChildren, setChildren);
        List<T> result = new ArrayList<>();
        tree2List(result, list.get(0), getChildren, setChildren);
        return result;
    }

    /**
     * 将树转成列表。
     *
     * @param result      结果容器
     * @param t           树顶部元素
     * @param getChildren
     * @param <T>
     */
    private static <T> void tree2List(List<T> result, T t, Function<T, List<T>> getChildren, BiConsumer<T, List<T>> setChildren) {
        //根据条件判断是否需要添加至列表
        result.add(t);
        List<T> 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 list          树结构的基础数据集
     * @param getIdFn       获取主键的函数
     * @param getParentIdFn 获取父节点的函数
     * @param getChildrenFn 获取子集的函数
     * @param <T>           t
     * @param <R>           r
     * @return t
     */
    @SneakyThrows
    public static <T, R> List<T> treeOut(List<T> list, Function<T, R> getIdFn, Function<T, R> getParentIdFn, SFunction<T, R> getChildrenFn) {
        /*所有元素的Id*/
        List<Object> ids = list.stream().map(getIdFn).collect(Collectors.toList());
        /*查出所有顶级节点*/
        List<T> topLevel = list.stream().filter(x -> {
            R apply = getParentIdFn.apply(x);
            return !ids.contains(apply);
        }).collect(Collectors.toList());
        return TreeUtil.recursion(topLevel, list, getIdFn, getParentIdFn, getChildrenFn);
    }
/**
     * 指定顶级元素
     * @param list
     * @param top
     * @param getIdFn
     * @param getParentIdFn
     * @param getChildrenFn
     * @param <T>
     * @param <R>
     * @return
     */
    @SneakyThrows
    public static <T, R> List<T> treeOutWithTop(List<T> list, T top, Function<T, R> getIdFn, Function<T, R> getParentIdFn, SFunction<T, R> getChildrenFn) {
        ArrayList<T> ts = new ArrayList<>();
        ts.add(top);
        return TreeUtil.recursion(ts, list, getIdFn, getParentIdFn, getChildrenFn);
    }

    @SneakyThrows
    private static <T, R> List<T> recursion(List<T> superLevel, List<T> list, Function<T, R> getIdFn, Function<T, R> getParentIdFn, SFunction<T, R> getChildrenFn) {
        //获取setChildren的Method
        Method writeReplaceMethod = getChildrenFn.getClass().getDeclaredMethod("writeReplace");
        boolean accessible = writeReplaceMethod.isAccessible();
        writeReplaceMethod.setAccessible(true);
        SerializedLambda serializedLambda = (SerializedLambda) writeReplaceMethod.invoke(getChildrenFn);
        writeReplaceMethod.setAccessible(accessible);
        String setMethodName = serializedLambda.getImplMethodName().replaceFirst("g", "s");
        Method setMethod = Class.forName(serializedLambda.getImplClass().replace("/", ".")).getDeclaredMethod(setMethodName, List.class);

        for (T t : superLevel) {
            List<T> children = list.stream().filter(x -> {
                R apply = getParentIdFn.apply(x);
                R apply1 = getIdFn.apply(t);
                return apply.equals(apply1);
            }).collect(Collectors.toList());
            if (children.size() <= 0) {
                continue;
            }

            List<T> recursion = recursion(children, list, getIdFn, getParentIdFn, getChildrenFn);
            setMethod.invoke(t, recursion);
        }
        return superLevel;
    }


}