Java 万物皆可 Tree 工具类

最新推荐文章于 2024-03-12 10:47:51 发布
最新推荐文章于 2024-03-12 10:47:51 发布
阅读量3.8k 收藏 11
点赞数 2
分类专栏： 常用工具类 java 面向对象 文章标签： 树形结构 tree java tree TreeUtils 通用 Tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/after95/article/details/112188070
版权

这是一套可以解决各种类型的数据构建树形结构的解决方案

方案一（推荐）

ITree - 树数据接口

import org.apache.commons.lang.StringUtils;

import java.util.List;

/**
 * 树接口
 *
 * @author: Neo
 * @date: 2021/1/4 14:24
 * @version: 1.0
 */
public interface ITree<T, K> {


    /**
     * 节点ID
     *
     * @return
     */
    K id();


    /**
     * 父节点ID
     *
     * @return
     */
    K parentId();

    /**
     * 设置父节点
     * 
     * @param parent
     */
    default void parent(T parent){
    }

    /**
     * 用于拼接 path 的属性
     * 
     * child.path(parentNode.path() + spliterator + child.pathProperty());
     * 
     * @return
     */
    default String pathProperty(){
        return StringUtils.EMPTY;
    }
    
    /**
     * 获取节点名称
     *
     * @return
     */
    default String path() {
        return StringUtils.EMPTY;
    }

    /**
     * 设置节点名称
     *
     * @param path
     */
    default void path(String path) {
    }

    /**
     * 排序
     *
     * @return
     */
    default Integer index() {
        return 0;
    }

    /**
     * 设置子节点
     *
     * @param children
     */
    default void children(List<T> children) {
    }
}

TreeUtils - 万物皆可 Tree 工具类

import org.apache.commons.collections.CollectionUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * 将扁平数据构造成树结构
 *
 * @author: Neo
 * @date: 2021/1/4 16:49
 * @version: 1.0
 */
public class TreeUtils {

    public static final String DEFAULT_SPLITERATOR = "/";

    private TreeUtils() {
    }


    enum Model {
        TREE, PATH, TREE_AND_PATH
    }


    /**
     * 构造树的入口方法
     *
     * @param originData    数据列表
     * @param rootPredicate 根节点条件
     * @param <T>           implements ITree
     * @param <K>           implements Serializable
     * @return
     */
    public static <T extends ITree<T, K>, K extends Serializable> List<T> buildTree(List<T> originData, Predicate<T> rootPredicate) {
        return baseBuild(Model.TREE, originData, null, rootPredicate);
    }


    /**
     * 构建树路径，不改变数据结构
     *
     * @param originData
     * @param rootPredicate
     * @param <T>
     * @param <K>
     * @return
     */
    public static <T extends ITree<T, K>, K extends Serializable> List<T> buildPath(List<T> originData, Predicate<T> rootPredicate) {
        return buildPath(originData, DEFAULT_SPLITERATOR, rootPredicate);
    }

    /**
     * 构建树路径，不改变数据结构
     *
     * @param originData
     * @param spliterator
     * @param rootPredicate
     * @param <T>
     * @param <K>
     * @return
     */
    public static <T extends ITree<T, K>, K extends Serializable> List<T> buildPath(List<T> originData, CharSequence spliterator, Predicate<T> rootPredicate) {
        return baseBuild(Model.PATH, originData, spliterator, rootPredicate);
    }

    /**
     * 构建树和路径
     *
     * @param originData
     * @param rootPredicate
     * @param <T>
     * @param <K>
     * @return
     */
    public static <T extends ITree<T, K>, K extends Serializable> List<T> buildTreeAndPath(List<T> originData, Predicate<T> rootPredicate) {
        return buildTreeAndPath(originData, DEFAULT_SPLITERATOR, rootPredicate);
    }

    /**
     * 构建树和路径
     *
     * @param originData
     * @param spliterator
     * @param rootPredicate
     * @param <T>
     * @param <K>
     * @return
     */
    public static <T extends ITree<T, K>, K extends Serializable> List<T> buildTreeAndPath(List<T> originData, CharSequence spliterator, Predicate<T> rootPredicate) {
        return baseBuild(Model.TREE_AND_PATH, originData, spliterator, rootPredicate);
    }


    /**
     * 树构建的基础方法
     *
     * @param model
     * @param originData
     * @param spliterator
     * @param rootPredicate
     * @param <T>
     * @param <K>
     * @return
     */
    public static <T extends ITree<T, K>, K extends Serializable> List<T> baseBuild(Model model,
                                                                                    List<T> originData,
                                                                                    CharSequence spliterator,
                                                                                    Predicate<T> rootPredicate) {
        if (Objects.isNull(model) || CollectionUtils.isEmpty(originData) || Objects.isNull(rootPredicate)) {
            return Collections.EMPTY_LIST;
        }

        List<T> result = new ArrayList<>(CollectionUtils.size(originData));

        List<T> roots = originData.stream().filter(rootPredicate).sorted(Comparator.comparing(T::index)).collect(Collectors.toList());

        if (CollectionUtils.isEmpty(roots)) {
            return Collections.EMPTY_LIST;
        }

        // 删除根节点，避免重复遍历
        originData.removeAll(roots);

        switch (model) {
            case TREE:
                roots.forEach(r -> result.add(buildTree(r, originData)));
                break;
            case PATH:
                roots.forEach(r -> result.addAll(buildPath(r, originData, spliterator)));
                break;
            case TREE_AND_PATH:
                roots.forEach(r -> result.add(buildTreeAndPath(r, originData, spliterator)));
                break;
            default:
                throw new RuntimeException();
        }
        return result;
    }


    /**
     * 构建子节点
     *
     * @param parentNode 父节点
     * @param originData 数据列表
     * @param <T>        implements ITree
     * @param <K>        implements Serializable
     * @return
     */
    public static <T extends ITree<T, K>, K extends Serializable> T buildTree(T parentNode, List<T> originData) {
        List<T> childrenNode = new ArrayList<>();

        List<T> children = filterByParentId(parentNode.id(), originData);

        if (CollectionUtils.isNotEmpty(children)) {
            // 删除节点，避免重复遍历
            originData.removeAll(children);
        }
        for (T child : children) {
            child.parent(parentNode);
            childrenNode.add(buildTree(child, originData));
        }
        parentNode.children(childrenNode);
        return parentNode;
    }


    /**
     * 构建子节点路径
     *
     * @param parentNode
     * @param originData
     * @param spliterator
     * @param <T>
     * @param <K>
     * @return
     */
    public static <T extends ITree<T, K>, K extends Serializable> List<T> buildPath(T parentNode, List<T> originData, CharSequence spliterator) {
        List<T> result = new ArrayList<>();

        List<T> children = filterByParentId(parentNode.id(), originData);

        result.add(parentNode);

        if (CollectionUtils.isEmpty(children)) {
            return result;
        }

        // 删除节点，避免重复遍历
        originData.removeAll(children);

        for (T child : children) {
            child.parent(parentNode);
            child.path(parentNode.path() + spliterator + child.pathProperty());
            result.addAll(buildPath(child, originData, spliterator));
        }
        parentNode.children(children);
        return result;
    }

    /**
     * 构建树和路径
     *
     * @param parentNode
     * @param originData
     * @param spliterator
     * @param <T>
     * @param <K>
     * @return
     */
    public static <T extends ITree<T, K>, K extends Serializable> T buildTreeAndPath(T parentNode, List<T> originData, CharSequence spliterator) {
        List<T> children = filterByParentId(parentNode.id(), originData);

        if (CollectionUtils.isNotEmpty(children)) {
            originData.removeAll(children);
        }

        for (T child : children) {
            child.parent(parentNode);
            child.path(parentNode.path() + spliterator + child.path());
            buildTreeAndPath(child, originData, spliterator);
        }

        parentNode.children(children);
        return parentNode;

    }


    /**
     * @param parentId   父节点ID
     * @param originData 数据列表
     * @param <T>        implements ITree
     * @param <K>        implements Serializable
     * @return
     */
    public static <T extends ITree<T, K>, K extends Serializable> List<T> filterByParentId(K parentId, List<T> originData) {
        return originData.stream()
                .filter(i -> Objects.equals(parentId, i.parentId()))
                .sorted(Comparator.comparing(T::index))
                .collect(Collectors.toList());

    }
}

TestTree - 测试对象

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.List;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TestTree implements ITree<TestTree, Long>, Serializable {
    private static final long serialVersionUID = -9153069020164026942L;
    
    private Long id;
    
    private String name;

    private Long parentId;

    private Integer index;

    private List<TestTree> children;


    @Override
    public Long id() {
        return this.id;
    }

    @Override
    public Long parentId() {
        return this.parentId;
    }

    @Override
    public String path() {
        return this.name;
    }

    @Override
    public void path(String path) {
        this.name = path;
    }
    
    @Override
    public Integer index() {
        return this.index;
    }

    @Override
    public void children(List<TestTree> children) {
        this.children = children;
    }
}

TreeUtilsTest - 测试类

import cn.hutool.json.JSONStrFormater;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;

import java.util.List;
import java.util.Objects;

public class TreeUtilsTest {

    public static void main(String[] args) {
        List<TestTree> testTrees;
        System.out.println("=========================【buildTree】============================");
        testTrees = TreeUtils.buildTree(initData(), tree -> Objects.isNull(tree.parentId()));
        System.out.println(JSONStrFormater.format(JSON.toJSONString(testTrees)));
        System.out.println("=========================【buildPath】============================");
        testTrees = TreeUtils.buildPath(initData(), tree -> Objects.isNull(tree.parentId()));
        System.out.println(JSONStrFormater.format(JSON.toJSONString(testTrees)));
        System.out.println("======================【buildTreeAndPath】=========================");
        testTrees = TreeUtils.buildTreeAndPath(initData(), tree -> Objects.isNull(tree.parentId()));
        System.out.println(JSONStrFormater.format(JSON.toJSONString(testTrees)));
    }
    
    static List<TestTree> initData(){
        return Lists.newArrayList(
                TestTree.builder().id(1L).parentId(null).name("一级-1").index(1).build(),
                TestTree.builder().id(2L).parentId(null).name("一级-2").index(2).build(),
                TestTree.builder().id(3L).parentId(null).name("一级-3").index(3).build(),

                TestTree.builder().id(4L).parentId(1L).name("二级-1").index(1).build(),
                TestTree.builder().id(5L).parentId(1L).name("二级-2").index(2).build(),
                TestTree.builder().id(6L).parentId(1L).name("二级-3").index(3).build(),

                TestTree.builder().id(7L).parentId(4L).name("三级-1").index(1).build(),
                TestTree.builder().id(8L).parentId(4L).name("三级-2").index(2).build(),
                TestTree.builder().id(9L).parentId(4L).name("三级-3").index(3).build()
        );
    }
}

测试结果

=========================【buildTree】============================
[
    {
        "children":
        [
            {
                "children":
                [
                    {
                        "children":
                        [
                            
                        ],
                        "id":7,
                        "index":1,
                        "name":"三级-1",
                        "parentId":4
                    },
                    {
                        "children":
                        [
                            
                        ],
                        "id":8,
                        "index":2,
                        "name":"三级-2",
                        "parentId":4
                    },
                    {
                        "children":
                        [
                            
                        ],
                        "id":9,
                        "index":3,
                        "name":"三级-3",
                        "parentId":4
                    }

                ],
                "id":4,
                "index":1,
                "name":"二级-1",
                "parentId":1
            },
            {
                "children":
                [
                    
                ],
                "id":5,
                "index":2,
                "name":"二级-2",
                "parentId":1
            },
            {
                "children":
                [
                    
                ],
                "id":6,
                "index":3,
                "name":"二级-3",
                "parentId":1
            }

        ],
        "id":1,
        "index":1,
        "name":"一级-1"
    },
    {
        "children":
        [
            
        ],
        "id":2,
        "index":2,
        "name":"一级-2"
    },
    {
        "children":
        [
            
        ],
        "id":3,
        "index":3,
        "name":"一级-3"
    }

]
=========================【buildPath】============================
[
    {
        "id":1,
        "index":1,
        "name":"一级-1"
    },
    {
        "id":4,
        "index":1,
        "name":"一级-1/二级-1",
        "parentId":1
    },
    {
        "id":7,
        "index":1,
        "name":"一级-1/二级-1/三级-1",
        "parentId":4
    },
    {
        "id":8,
        "index":2,
        "name":"一级-1/二级-1/三级-2",
        "parentId":4
    },
    {
        "id":9,
        "index":3,
        "name":"一级-1/二级-1/三级-3",
        "parentId":4
    },
    {
        "id":5,
        "index":2,
        "name":"一级-1/二级-2",
        "parentId":1
    },
    {
        "id":6,
        "index":3,
        "name":"一级-1/二级-3",
        "parentId":1
    },
    {
        "id":2,
        "index":2,
        "name":"一级-2"
    },
    {
        "id":3,
        "index":3,
        "name":"一级-3"
    }

]
======================【buildTreeAndPath】=========================
[
    {
        "children":
        [
            {
                "children":
                [
                    {
                        "children":
                        [
                            
                        ],
                        "id":7,
                        "index":1,
                        "name":"一级-1/二级-1/三级-1",
                        "parentId":4
                    },
                    {
                        "children":
                        [
                            
                        ],
                        "id":8,
                        "index":2,
                        "name":"一级-1/二级-1/三级-2",
                        "parentId":4
                    },
                    {
                        "children":
                        [
                            
                        ],
                        "id":9,
                        "index":3,
                        "name":"一级-1/二级-1/三级-3",
                        "parentId":4
                    }

                ],
                "id":4,
                "index":1,
                "name":"一级-1/二级-1",
                "parentId":1
            },
            {
                "children":
                [
                    
                ],
                "id":5,
                "index":2,
                "name":"一级-1/二级-2",
                "parentId":1
            },
            {
                "children":
                [
                    
                ],
                "id":6,
                "index":3,
                "name":"一级-1/二级-3",
                "parentId":1
            }

        ],
        "id":1,
        "index":1,
        "name":"一级-1"
    },
    {
        "children":
        [
            
        ],
        "id":2,
        "index":2,
        "name":"一级-2"
    },
    {
        "children":
        [
            
        ],
        "id":3,
        "index":3,
        "name":"一级-3"
    }

]

方案二

BuildTreeUtils

import org.apache.commons.collections.CollectionUtils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;


/**
 * 构造树
 *
 * @author: Neo
 * @date: 2020/12/24 17:26
 * @version: 1.0
 */
public class BuildTreeUtils {


    /**
     * @param treeList  数据列表
     * @author: Neo
     * @aate: 2020/12/24 17:27
     * @version: 1.0
     */
    public static <T extends BaseTree<T>> List<T> buildTree(List<T> treeList) {

        List<T> firstNodeList = buildChildren(0L, treeList);
        if (CollectionUtils.isEmpty(firstNodeList)) {
            return Collections.EMPTY_LIST;
        }

        List<T> result = new ArrayList<>();
        for (T node : firstNodeList) {
            T n = buildChildren(node, treeList);
            result.add(n);
        }
        return result;
    }

    public static <T extends BaseTree<T>> T buildChildren(T node, List<T> list) {
        List<T> childrenNode = new ArrayList<>();
        List<T> children = buildChildren(node.getId(), list);
        for (T child : children) {
            childrenNode.add(buildChildren(child, list));
        }
        node.setChildren(childrenNode);
        return node;
    }


    public static <T extends BaseTree<T>> List<T> buildChildren(Long parentId, List<T> list) {
        return list.stream()
                .filter(i -> Objects.equals(parentId, i.getParentId()))
                .sorted(Comparator.comparing(T::getIndex))
                .collect(Collectors.toList());

    }

}

BaseTree

import cn.hutool.core.convert.Convert;
import lombok.Data;

import java.io.Serializable;
import java.util.List;
import java.util.Objects;

@Data
public class BaseTree<T> implements Serializable {
    private static final long serialVersionUID = -4881070396277928428L;

    /**
     * 主键ID
     */
    private Long id;

    /**
     * 父编号
     */
    private Long parentId;

    private Integer viewIndex;

    private List<T> children;

    public Integer getIndex() {
        return Objects.nonNull(this.viewIndex) ? this.viewIndex : Convert.toInt(this.id);
    }
}
after95
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
i-Tree最新版2019年中文操作手册
03-05
i-Tree最新版2019年中文操作手册，i-Tree是代替CITYgreen模型的升级版本，适合大家下载观看学习。
【Java用法】Hutool树结构工具-TreeUtil快速构建树形结构的两种方式 + 数据排序
No8g攻城狮的博客
12-08 8368
考虑到菜单等需求的普遍性，有用户提交了一个扩展性极好的树状结构实现。这种树状结构可以根据配置文件灵活的定义节点之间的关系，也能很好的兼容关系数据库中数据。实现 关系型数据库数据 Tree JSON 树状结构中最大的问题就是关系问题，在数据库中，每条数据通过某个字段关联自己的父节点，每个业务中这个字段的名字都不同，如何解决这个问题呢？PR的提供者提供了一种解决思路：自定义字段名，节点不再是一个bean，而是一个map，实现灵活的字段名定义。
java树结构通用工具类
m0_71642243的博客
05-16 526
左树的通用utils
Java工具类之TreeUtils，构建树形数据结构
最新发布
昨日清风的博客
03-12 1488
在实际项目开发过程中，我们可能会遇到需要将数据以树形结构的形式进行展示，比如：权限数、菜单树等等，虽然现在很多前端工具类可以自行构建（比如treegrid等），但为了方便，完全可以在后端进行数据的树形结构构建。注意，本人目前使用的JDK版本为21，但理论上JDK11及以上版本都应该是适配的，如果移植时有错误，根据自己JDK版本修改特性进行适配。
java实现的树形结构工具类TreeUtil
XiaoZhongYu的博客
09-19 696
java实现的树形结构工具类TreeUtil
JAVA 实现 tree 树形结构集合封装工具类，通用，高自定义，一条SQL语句、两次循环搞定；不需要递归，不需要一级一级的循环查询，只需将数据查询出来。
panghu_panghu的博客
12-01 884
自定义层级查询，自定义参数，还可以将id和parentId的Long类型换成String类型，这样可用自定义的编码来实现树形；要查询的数据示例（只留了部分区域层级作为演示）下面放有此数据的sql语句。
java TreeUtil菜单递归工具类
09-07
在Java编程中，`TreeUtil` 是一个常用的工具类，用于处理树形结构的数据，特别是构建和操作菜单或层级结构。在上述代码中，`TreeUtil` 被设计用来生成菜单树，它通过递归的方式将扁平化的菜单列表转换成具有层级关系...
tree-sitter-java:树保姆的Java语法
04-17
总结来说，“tree-sitter-java”是Java开发者的一个强大工具，它利用了先进的解析技术，提供了高效、准确的语法分析能力。无论是在开发环境中的实时反馈，还是在代码维护阶段的分析和重构，它都能发挥重要作用。通过...
redis工具类以及redis 连接池配置
07-01
工具类中包括存放hash表键值对，键值对以map的方式储存，删除键值对，永久存放键值对，设置过期时间，需要的直接去gitHab上看https://github.com/1610220353/advancedGiants/tree/master/src/main
TreeUtil工具类
11-25
在Java编程中，TreeUtil工具类是一个非常实用的辅助类，尤其在处理树形数据结构时。树形结构广泛应用于各种场景，如文件系统、组织结构、菜单系统等。TreeUtil通常包含一系列静态方法，方便开发者对树节点进行操作，...
java导出excel树结构工具类
01-21
该工具类实现java导出树形结构的方法，并未采用excel分组功能实现，而是根据树节点显示层级设置excel样式。针对easyUi，treeGrid开发的导出excel功能。方法简便实用、性强、通俗易懂。项目中亲测，no problem。
JAVA构建树形结构通用工具类
postivedragon的博客
06-07 4495
JAVA构建树形结构通用工具类场景说明构建思路实现第一步:构建接口TreeFeature第二步:让需要构建树形结构的类实现该接口并实现方法功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 场景说明 在日常java开发过程中，经常遇到
Java通过注解构建树结构工具类
立刻有，不强求
06-09 367
在Java中，注解是一种元数据，可以提供有关代码的附加信息。通过使用注解，可以在代码中添加配置信息、验证条件、文档和其他信息，这使得代码更易于理解和维护。
java树泛型工具类
weixin_42895341的博客
08-31 189
JAVA构建树形结构通用工具类 场景说明 案例中的方法说明 构建思路实现 第一步:构建接口TreeFeature 第二步:让需要构建树形结构的类实现该接口并实现方法 第三部创建通用的TreeUtil工具类 到这位置，TreeUtil已经完成来测试,先在实体类中添加点测试数据 编写测试类 输出结果 当有一个新的需要构建树形结构的实体时，只需要实现TreeFeature接口并重写好其中的方法，调用TreeUtil .build即可 场景说明 在日常java开发过程中，经常遇到要把一个扁平结构的数据，处理成为树形
Java工具类 - 树状结构工具类（List转树形数据）
qq_42131992的博客
06-15 2657
Java 集合转树状数据工具类
使用java构建树形结构的多种实现工具类
weixin_42645678的博客
11-20 532
属性节点和工具类构成，个人比较喜欢用的是最后一个celerityBuild，n*2即可快速构建出树。比较通用的一套树形结构构建工具类。
详细分析Java的树形工具类ForestNodeMerger（含注释）
码农研究僧的博客
01-27 928
对应的基本知识推荐如下： 【数据结构】树和二叉树详细分析（全） 【数据结构】B树和B+树的笔记详细诠释
java集合构建成树形集合TreeUtil
qq_41604890的博客
03-13 4427
定义树形结构接口 import java.util.List; /** * 树形结构基础类 * @param <T> */ public interface BaseTree<T> { String getId(); void setId(String id); String getPid(); void setPid(String pid); List<T> getChildren(); void se
自定义tree工具类 TreeUtils.java
Andrew_Chenwq的博客
08-25 256
【代码】自定义tree工具类 TreeUtils.java。
java 输出树形结构工具类
03-31
以下是一个 Java 工具类，可以将树形结构数据输出为字符串： ```java import java.util.List; public class TreePrinter { private static final String LINE_PREFIX = " "; private static final String ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值