Java工具类 - 将List转换为树状结构

---

直接复制即可

---

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
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.function.Supplier;
import java.util.stream.Collectors;

/**
 * @program: myUtil
 * @description: 工具类 - 树状结构生成
 * @author: syf
 * @create: 2021-06-15 10:38
 */
public class TreeModel {

    /**
     * 上级字段名称
     */
    private Function superColumn;

    /**
     * 当前比对字段
     */
    private Function column;

    /**
     * 列表接收字段名
     */
    private BiConsumer> children;

    /**
     * 数据列表
     */
    private List list;

    /**
     * 数据解除关联性使用的对象
     */
    private Supplier decoupling;

    /**
     * 私有化工具类
     */
    private TreeModel() {
    }

    /**
     * 初始化载入树状工具类
     *
     * @param list        需要整合的数据列表
     * @param superColumn 上级字段(对象::字段get方法)
     * @param column      本级字段(对象::字段get方法)
     * @param children    下级数据存储字段(对象::字段set方法)
     * @return 树状工具类
     */
    public static  TreeModel load(List list, Function superColumn,
                                        Function column, BiConsumer> children) {
        TreeModel treeModel = new TreeModel<>();
        treeModel.setSuperColumn(superColumn)
                .setColumn(column)
                .setChildren(children)
                .setList(list);
        return treeModel;
    }

    /**
     * 获取树状数据（不解除原集合中对象与树状集合对象的关联）
     *
     * @param initValue 根数据
     * @return 树状数据数据列表
     */
    public List getTree(Object initValue) {
        List tree = treeAll(initValue);
        if (tree != null && tree.size() > 0) {
            return tree.stream().filter(ls -> initValue.equals(superColumn.apply(ls))).collect(Collectors.toList());
        }
        return tree;
    }

    /**
     * 获取树状数据（解除原集合中对象与树状集合对象的关联）
     *
     * @param initValue  根数据
     * @param decoupling 解除关联对象（对象::new）
     * @return 树状数据数据列表
     */
    public List getTree(Object initValue, Supplier decoupling) {
        this.setDecoupling(decoupling);
        return tree(initValue);
    }

    /**
     * 获取树状数据
     *
     * @param initValue 根数据
     * @return 树状数据
     */
    private List treeAll(Object initValue) {
        if (list == null || list.size() < 1) {
            return list;
        }
        List collect = list.stream().filter(f -> initValue.equals(superColumn.apply(f))).collect(Collectors.toList());
        if (collect.size() < 1) {
            return null;
        }
        collect.forEach(c -> children.accept(c, treeAll(column.apply(c))));
        return collect;
    }

    private List tree(Object o) {
        List childrenList = new ArrayList<>();
        if(o == null){
            return childrenList;
        }
        for (T entity : list) {
            if (o.equals(superColumn.apply(entity))) {
                T now = decoupling.get();
                copy(entity, now);
                childrenList.add(now);
            }
        }
        for (T cs : childrenList) {
            children.accept(cs, tree(column.apply(cs)));
        }
        return childrenList;
    }

    /**
     * 将source中的属性赋值给target
     * @param source    数据来源类
     * @param target    数据接收类
     */
    private void copy(T source, T target) {
        if (source == null) {
            throw new NullPointerException("dataSource");
        }
        if (target == null) {
            target = decoupling.get();
        }
        Field[] sourceFields = source.getClass().getDeclaredFields();
        Field[] targetFields = target.getClass().getDeclaredFields();
        Map sourceMap = new HashMap<>(sourceFields.length);
        try {
            for (Field field : sourceFields) {
                if (Modifier.isFinal(field.getModifiers())) {
                    continue;
                }
                field.setAccessible(true);
                sourceMap.put(field.getName(), field.get(source));

            }
            for (Field field : targetFields) {
                Object o = sourceMap.get(field.getName());
                if (o == null) {
                    continue;
                }
                field.setAccessible(true);
                field.set(target, o);
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    private TreeModel setSuperColumn(Function superColumn) {
        if (superColumn == null) {
            throw new NullPointerException("superColumn");
        }
        this.superColumn = superColumn;
        return this;
    }

    private TreeModel setColumn(Function column) {
        if (column == null) {
            throw new NullPointerException("column");
        }
        this.column = column;
        return this;
    }

    private TreeModel setChildren(BiConsumer> children) {
        if (children == null) {
            throw new NullPointerException("children");
        }
        this.children = children;
        return this;
    }

    private void setList(List list) {
        if (list == null || list.size() < 1) {
            throw new NullPointerException("list");
        }
        this.list = list;
    }

    private void setDecoupling(Supplier decoupling) {
        if (decoupling == null) {
            throw new NullPointerException("decoupling");
        }
        this.decoupling = decoupling;
    }

}

使用方法：

TreeModel tree = TreeModel.load(list, Entity::getSuperId, Entity::getSunId, Entity::setCheildren);
tree.getTree("根数据"); // 不解除原有集合中对象与树状集合中对象的关联
tree.getTree("根数据", Entity::new); // 解除原有集合中对象与树状集合中对象的关联