Java 树形结构工具类

kuro-shiro

已于 2024-08-27 16:06:27 修改

阅读量109

点赞数 2

分类专栏： java 文章标签： java

于 2024-08-26 10:04:11 首次发布

本文链接：https://blog.csdn.net/laiyucannian/article/details/141556183

版权

java 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

一、定义接口，统一规范

/**
 * 树形结构基础接口
 */
public interface TreeNodeBase<T> {
    /**
     * @return 获取当前元素Id
     */
    Object getId();

    /**
     * @return 获取父元素Id
     */
    Object getParentId();

    /**
     * @return 获取当前元素的 children 属性
     */
    List<T> getChildren();

}

二、编写工具类 TreeNodeUtil

/**
 * 树形结构工具类
 */
public class TreeNodeUtil {

    public static final String PARENT_NAME = "parent";

    public static final String CHILDREN_NAME = "children";

    /**
     * 根节点ID，默认为0
     */
    public static final List<Object> ROOT_NODE_IDS = Collections.singletonList(0l);



    /**
     * 数据集合构建成树形结构
     *
     * @param dataList 数据集合
     * @return
     */
    public static <T extends TreeNodeBase> List<T> buildTree(List<T> dataList) {
        return buildTree(dataList, ROOT_NODE_IDS, (data) -> data, (item) -> true);
    }

    /**
     * 数据集合构建成树形结构
     *
     * @param dataList 数据集合
     * @param map 调用者提供 Function<T, T> ，可对数据进行操作
     * @return
     */
    public static <T extends TreeNodeBase> List<T> buildTree(List<T> dataList, Function<T, T> map) {
        return buildTree(dataList, ROOT_NODE_IDS, map, (item) -> true);
    }

    /**
     * 数据集合构建成树形结构
     *
     * @param dataList 数据集合
     * @param filter 调用者提供 Predicate<T> 用于数据过滤
     * @return
     */
    public static <T extends TreeNodeBase> List<T> buildTree(List<T> dataList, Predicate<T> filter) {
        return buildTree(dataList, ROOT_NODE_IDS, (data) -> data, filter);
    }

    /**
     * 数据集合构建成树形结构
     *
     * @param dataList 数据集合
     * @param map 调用者提供 Function<T, T> ，可对数据进行操作
     * @param filter 调用者提供 Predicate<T> 用于数据过滤
     * @return
     */
    public static <T extends TreeNodeBase> List<T> buildTree(List<T> dataList, Function<T, T> map, Predicate<T> filter) {
        return buildTree(dataList, ROOT_NODE_IDS, map, filter);
    }

    /**
     * 数据集合构建成树形结构
     *
     * @param dataList 数据集合
     * @param rootIds 初始节点的 Id 集合
     * @return
     */
    public static <T extends TreeNodeBase> List<T> buildTree(List<T> dataList, List<Object> rootIds) {
        return buildTree(dataList, rootIds,(data) -> data, (item) -> true);
    }

    /**
     * 数据集合构建成树形结构
     *
     * @param dataList 数据集合
     * @param rootIds 初始节点的 Id 集合
     * @param map 调用者提供 Function<T, T> ，可对数据进行操作
     * @return
     */
    public static <T extends TreeNodeBase> List<T> buildTree(List<T> dataList, List<Object> rootIds, Function<T, T> map) {
        return buildTree(dataList, rootIds, map, (item) -> true);
    }
    /**
     * 数据集合构建成树形结构
     *
     * @param dataList 数据集合
     * @param rootIds 初始节点的 Id 集合
     * @param filter 调用者提供 Predicate<T> 用于数据过滤
     * @return
     */
    public static <T extends TreeNodeBase> List<T> buildTree(List<T> dataList, List<Object> rootIds, Predicate<T> filter) {
        return buildTree(dataList, rootIds, (data) -> data, filter);
    }



    /**
     * 数据集合构建成树形结构 （ 注: 如果最开始的 ids 不在 dataList 中，不会进行任何处理 ）
     *
     * @param dataList 数据集合
     * @param rootIds 初始节点的 Id 集合
     * @param map 调用者提供 Function<T, T> ，可对数据进行操作
     * @param filter 调用者提供 Predicate<T> 用于数据过滤
     * @return
     */
    public static <T extends TreeNodeBase> List<T> buildTree(List<T> dataList, List<Object> rootIds, Function<T, T> map, Predicate<T> filter) {
        if(map==null){
            //对数据进行操作的方法为null时提供默认方法
            map = (data)->data;
        }
        if(filter==null){
            //对数据进行过滤的方法为null时提供默认方法
            filter = (data)->true;
        }
        if (CollectionUtils.isEmpty(rootIds)) {
            return Collections.emptyList();
        }
        // 1. 将数据分为 父子结构
        Map<String, List<T>> nodeMap = dataList.stream()
                .filter(filter)
                .collect(Collectors.groupingBy(item -> rootIds.contains(item.getParentId()) ? PARENT_NAME : CHILDREN_NAME));

        List<T> parent = nodeMap.getOrDefault(PARENT_NAME, Collections.emptyList());
        List<T> children = nodeMap.getOrDefault(CHILDREN_NAME, Collections.emptyList());
        // 1.1 如果未分出或过滤了父元素则将子元素返回
        if (parent.size() == 0) {
            return Collections.emptyList();
        }
        // 2. 存储下一次处理的父节点ids
        List<Object> nextIds = new ArrayList<>(dataList.size());
        // 3. 遍历父元素 以及修元素内容
        List<T> collectParent = parent.stream().map(map).collect(Collectors.toList());
        for (T parentItem : collectParent) {
            // 3.1 如果子元素已经加完，直接进入下一轮循环
            if (nextIds.size() == children.size()) {
                break;
            }
            // 3.2 过滤出 parent.id == children.parentId 的元素
            children.stream()
                    .filter(childrenItem -> parentItem.getId().equals(childrenItem.getParentId()))
                    .forEach(childrenItem -> {
                        // 3.3 这次的子元素为下一次的父元素
                        nextIds.add(childrenItem.getParentId());
                        // 3.4 添加子元素到 parentItem.children 中
                        parentItem.getChildren().add(childrenItem);
                    });
        }
        buildTree(children, nextIds, map, filter);
        return parent;
    }

}

三、测试

/**
 * 树形结构测试
 */
@Data
public class TreeNodeDemo implements TreeNodeBase<TreeNodeDemo> {
    private Long id;

    private String name;


    private Long parentId;

    public TreeNodeDemo(Long id, String name, Long parentId) {
        this.id = id;
        this.name = name;
        this.parentId = parentId;
    }

    private List<TreeNodeDemo> children = new ArrayList<>();


    public static void main(String[] args) {
        List<TreeNodeDemo> testChildren = new ArrayList<>();
        testChildren.add(new TreeNodeDemo(1L, "父元素",  0L));
        testChildren.add(new TreeNodeDemo(2L, "子元素1",  1L));
        testChildren.add(new TreeNodeDemo(3L, "子元素2",  1L));
        testChildren.add(new TreeNodeDemo(4L, "子元素2的孙子元素",  3L));

        //默认根节点id为0开始构建树形结构
        System.out.println(JSON.toJSONString(TreeNodeUtil.buildTree(testChildren)));
        // //默认根节点id为0开始构建树形结构,并对符合要求的数据进行操作
        // System.out.println(JSON.toJSONString(TreeNodeUtil.buildTree(testChildren,(Function<TreeNodeDemo,TreeNodeDemo>)item->{
        //     if (item.getId().equals(1L)) {
        //         item.setName("更改了 Id 为 1L 的数据名称");
        //     }
        //     return item;
        // })));
        // //设置从根节点ID为1开始构建树形结构
        // System.out.println(JSON.toJSONString(TreeNodeUtil.buildTree(testChildren, Collections.singletonList(1L))));
        // //设置根节点ID为1开始构建树形结构并过滤父id为3的元素
        // System.out.println(JSON.toJSONString(TreeNodeUtil.buildTree(testChildren, Collections.singletonList(1L), (Predicate<TreeNodeDemo>) item -> Long.valueOf(3).equals(item.getParentId()))));
    }

}