随笔 - 754  文章 - 0 评论 - 33 阅读 - 135万
< 2025年3月 >
日 一 二 三 四 五 六
23 24 25 26 27 28 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31 1 2 3 4 5

java树形结构

在我们实际开发中会接触到树形结构,根节点子节点, 然后添加数据构成了我们的树形结构, 在Java后台利用递归思路进行构建树形结构数据，返回给前端，能以下拉菜单等形式进行展示, 以某市行政区为例

图:

一、java构建树形结构实现一

（1）、实体类

复制代码
@Data
public class TreeNode {

    /** 节点ID */
    private Integer id;

    /** 父节点ID：顶级节点为0 */
    private Integer parentId;

    /** 节点名称 */
    private String label;

    /** 子节点 */
    private List<TreeNode> children;
    /** 构造函数 */
    public TreeNode(Integer id, Integer parentId, String label) {
        this.id = id;
        this.parentId = parentId;
        this.label = label;
    }
}
复制代码

（2）、实现类

实现步骤：

（1）、获取所有根节点

（2）、遍历所有根节点，递归构建子树形结构

复制代码
@Service
public class TreeBuild {

    // 保存参与构建树形的所有数据（通常数据库查询结果）
    public List<TreeNode> nodeList = new ArrayList<>();

    /**
     *  构造方法
     *  @param nodeList 将数据集合赋值给nodeList，即所有数据作为所有节点。
     */
    public TreeBuild(List<TreeNode> nodeList){
        this.nodeList = nodeList;
    }

    /**
     *   获取需构建的所有根节点（顶级节点） "0"
     *   @return 所有根节点List集合
     */
    public List<TreeNode> getRootNode(){
        // 保存所有根节点（所有根节点的数据）
        List<TreeNode> rootNodeList = new ArrayList<>();
        // treeNode：查询出的每一条数据（节点）
        for (TreeNode treeNode : nodeList){
            // 判断当前节点是否为根节点，此处注意：若parentId类型是String，则要采用equals()方法判断。
            if (0 == treeNode.getParentId()) {
                // 是，添加
                rootNodeList.add(treeNode);
            }
        }
        return rootNodeList;
    }

    /**
     *  根据每一个顶级节点（根节点）进行构建树形结构
     *  @return  构建整棵树
     */
    public List<TreeNode> buildTree(){
        // treeNodes：保存一个顶级节点所构建出来的完整树形
        List<TreeNode> treeNodes = new ArrayList<TreeNode>();
        // getRootNode()：获取所有的根节点
        for (TreeNode treeRootNode : getRootNode()) {
            // 将顶级节点进行构建子树
            treeRootNode = buildChildTree(treeRootNode);
            // 完成一个顶级节点所构建的树形，增加进来
            treeNodes.add(treeRootNode);
        }
        return treeNodes;
    }

    /**
     *  递归-----构建子树形结构
     *  @param  pNode 根节点（顶级节点）
     *  @return 整棵树
     */
    public TreeNode buildChildTree(TreeNode pNode){ // 调用一次该方法就相当于给TreeNode对象添加children属性
        List<TreeNode> childTree = new ArrayList<TreeNode>();
        // nodeList：所有节点集合（所有数据）
        for (TreeNode treeNode : nodeList) {
            // 判断当前节点的父节点ID是否等于根节点的ID，即当前节点为其下的子节点
            if (treeNode.getParentId().equals(pNode.getId())) {
                // 再递归进行判断当前节点的情况，调用自身方法
                childTree.add(buildChildTree(treeNode));
            }
        }
        // for循环结束，即节点下没有任何节点，树形构建结束，设置树结果
        pNode.setChildren(childTree);
        return pNode;
    }
}
复制代码

（3）、测试类

复制代码
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MySpringBootApplication.class)
public class Test2 {
    @Test
    public void test1() {
        // 模拟测试数据（通常为数据库的查询结果）
        List<TreeNode> treeNodeList = new ArrayList<>();
        treeNodeList.add(new TreeNode(1, 0, "顶级节点A"));
        treeNodeList.add(new TreeNode(2, 0, "顶级节点B"));
        treeNodeList.add(new TreeNode(3, 1, "父节点是A"));
        treeNodeList.add(new TreeNode(4, 2, "父节点是B"));
        treeNodeList.add(new TreeNode(5, 2, "父节点是B"));
        treeNodeList.add(new TreeNode(6, 3, "父节点的ID是3"));

        // 创建树形结构（数据集合作为参数）
        TreeBuild treeBuild = new TreeBuild(treeNodeList);
        // 原查询结果转换树形结构
        treeNodeList = treeBuild.buildTree();
        System.out.println(JSON.toJSONString(treeNodeList));
    }
}
复制代码

结果：

复制代码
[
    {
        "children": [
            {
                "children": [
                    {
                        "children": [ ], 
                        "id": 6, 
                        "label": "父节点的ID是3", 
                        "parentId": 3
                    }
                ], 
                "id": 3, 
                "label": "父节点是A", 
                "parentId": 1
            }
        ], 
        "id": 1, 
        "label": "顶级节点A", 
        "parentId": 0
    }, 
    {
        "children": [
            {
                "children": [ ], 
                "id": 4, 
                "label": "父节点是B", 
                "parentId": 2
            }, 
            {
                "children": [ ], 
                "id": 5, 
                "label": "父节点是B", 
                "parentId": 2
            }
        ], 
        "id": 2, 
        "label": "顶级节点B", 
        "parentId": 0
    }
]
复制代码

二、java构建树形结构实现二

（1）、实体类

复制代码
@Data
public class TreeSelect implements Serializable
{

    /** 节点ID */
    private Long id;

    /** 节点名称 */
    private String label;

    /** 父ID */
    private Long parentId;

    /** 子节点 */
    private List<TreeSelect> children;

    public TreeSelect(Long id, String label, Long parentId) {
        this.id = id;
        this.label = label;
        this.parentId = parentId;
    }

}
复制代码

（2）、实现类

复制代码
@Service
public class TreeSelectBuild {
    /**
     * 构建前端所需要树结构
     *
     * @param trees 列表
     * @return 树结构列表
     */
    public static List<TreeSelect> buildDeptTree(List<TreeSelect> trees) {
        List<TreeSelect> returnList = new ArrayList<TreeSelect>();
        List<Long> tempList = new ArrayList<Long>();
        for (TreeSelect dept : trees) {
            tempList.add(dept.getId()); // 所有数据的id
        }
        // for循环：表达式1：循环变量赋初值，表达式2：循环条件
        for (Iterator<TreeSelect> iterator = trees.iterator(); iterator.hasNext();) {
            TreeSelect treeSelect = (TreeSelect) iterator.next();
            // 如果是顶级节点, 遍历该父节点的所有子节点
            if (!tempList.contains(treeSelect.getParentId())) { // 筛选出所有顶级节点
                recursionFn(trees, treeSelect);
                returnList.add(treeSelect);
            }
        }
        if (returnList.isEmpty()) {
            returnList = trees;
        }
        return returnList;
    }
    /**
     * 递归列表,每执行一次该方法就向第二个参数TreeSelect设置属性值children
     */
    private static void recursionFn(List<TreeSelect> list, TreeSelect t) { // TreeSelect为顶级节点
        // 得到子节点列表
        List<TreeSelect> childList = getChildList(list, t);
        t.setChildren(childList);
        for (TreeSelect tChild : childList) { // 给每个tChild设置children属性值
            if (hasChild(list, tChild)) {
                recursionFn(list, tChild);
            }
        }
    }

    /**
     * 得到子节点列表
     */
    private static List<TreeSelect> getChildList(List<TreeSelect> list, TreeSelect t) {
        List<TreeSelect> tlist = new ArrayList<TreeSelect>();
        for (TreeSelect treeSelect : list) {
            if (null != treeSelect.getParentId() && treeSelect.getParentId().longValue() == t.getId().longValue()) {
                tlist.add(treeSelect);
            }
        }
        return tlist;
    }

    /**
     * 判断是否有子节点
     */
    private static boolean hasChild(List<TreeSelect> list, TreeSelect t) {
        return getChildList(list, t).size() > 0;
    }
}
复制代码

（3）、测试类

复制代码
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MySpringBootApplication.class)
public class Test3 {
    @Autowired
    private TreeSelectBuild treeSelectBuild;
    @Test
    public void test1() {
        List<TreeSelect> treeSelects = new ArrayList<>();
        treeSelects.add(new TreeSelect(1l, "顶级节点A",0l));
        treeSelects.add(new TreeSelect(2l, "顶级节点B",0l));
        treeSelects.add(new TreeSelect(3l, "父节点是A",1l));
        treeSelects.add(new TreeSelect(4l, "父节点是B",2l));
        treeSelects.add(new TreeSelect(5l, "父节点是B",2l));
        treeSelects.add(new TreeSelect(6l, "父节点的ID是3",3l));

        List<TreeSelect> treeSelects1 = treeSelectBuild.buildDeptTree(treeSelects);
        System.out.println(JSON.toJSONString(treeSelects1));
    }
}
复制代码

结果同上

三、java构建树形结构实现三

这种方式的特点是声明一个map，用来过滤已操作过的数据。

（1）、实体类

复制代码
@Data
public class Menu {
    private Long id;

    /**
     * 上级ID
     */
    private Long parentId;

    /**
     * 名称
     */
    private String name;

    private List<Menu> children;

    public Menu(Long id, String name, Long parentId) {
        this.id = id;
        this.parentId = parentId;
        this.name = name;
    }
}
复制代码

（2）、实现类

复制代码
@Service
public class MenuTreeBuild {

    public List<Menu> buildTree(List<Menu> list) {
        //封装成树形数据
        //最顶层根节点
        List<Menu> rootList = new ArrayList<>();
        //非最顶层根节点
        List<Menu> bodyList = new ArrayList<>();
        for (Menu menu : list) {
            if (menu.getParentId() == 0) {
                rootList.add(menu);
            } else {
                bodyList.add(menu);
            }
        }
        if (bodyList.size() > 0) {
            // 声明一个map，用来过滤已操作过的数据
            Map<String, Long> map = new HashMap<>(bodyList.size());
            // 遍历所有根节点，构建子树形结构
            rootList.forEach(parent -> getChild(parent, bodyList, map));
        }
        return rootList;
    }
    /**
     * 获取孩子节点
     *
     * @param parent
     * @param bodyList
     * @param map
     */
    private void getChild(Menu parent, List<Menu> bodyList, Map<String, Long> map) {
        List<Menu> childList = new ArrayList<>();
        bodyList.stream().filter(c -> !map.containsKey(c.getId()))
                .filter(c -> c.getParentId().equals(parent.getId()))
                .forEach(c -> {
                    map.put(c.getId() + "", c.getParentId());
                    getChild(c, bodyList, map);
                    childList.add(c);
                });
        parent.setChildren(childList);
    }
}
复制代码

（3）、测试类

复制代码
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MySpringBootApplication.class)
public class Test6 {
    @Autowired
    private MenuTreeBuild menuTreeBuild;
    @Test
    public void test1() {
        List<Menu> treeSelects = new ArrayList<>();
        treeSelects.add(new Menu(1l, "顶级节点A",0l));
        treeSelects.add(new Menu(2l, "顶级节点B",0l));
        treeSelects.add(new Menu(3l, "父节点是A",1l));
        treeSelects.add(new Menu(4l, "父节点是B",2l));
        treeSelects.add(new Menu(5l, "父节点是B",2l));
        treeSelects.add(new Menu(6l, "父节点的ID是3",3l));
        List<Menu> menus = menuTreeBuild.buildTree(treeSelects);
        System.out.println(JSON.toJSONString(menus));
    }
}
复制代码

结果同上

四、利用java8 Stream流实现树形结构（推荐）

（1）、实体类

复制代码
@Data
public class TreeSelect implements Serializable
{

    /** 节点ID */
    private Long id;

    /** 节点名称 */
    private String label;

    /** 父ID */
    private Long parentId;

    /** 子节点 */
    private List<TreeSelect> children;

    public TreeSelect(Long id, String label, Long parentId) {
        this.id = id;
        this.label = label;
        this.parentId = parentId;
    }

}
复制代码

（2）、实现类

复制代码
@Service
public class TreeSelectBuild {public static List<TreeSelect> buildDeptTreeByStream(List<TreeSelect> trees){
        //获取parentId = 0的根节点
        List<TreeSelect> list = trees.stream().filter(item -> item.getParentId() == 0L).collect(Collectors.toList());
        //根据parentId进行分组
        Map<Long, List<TreeSelect>> map = trees.stream().collect(Collectors.groupingBy(TreeSelect::getParentId));
        recursionFnTree(list, map);
        return list;
    }

    /**
     * 递归遍历节点设置children属性，参数一为上一级节点的集合，参数二为根据parentId进行分组后的map
     * @param list
     * @param map
     */
    public static void recursionFnTree(List<TreeSelect> list, Map<Long, List<TreeSelect>> map){
        for (TreeSelect treeSelect : list) { // 遍历所有根节点
            List<TreeSelect> childList = map.get(treeSelect.getId()); // 根据根节点的ID得到子节点
            treeSelect.setChildren(childList); // 设置children属性值
            if (null != childList && 0 < childList.size()){
                recursionFnTree(childList,map);
            }
        }
    }
}
复制代码

（3）、测试类

复制代码
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MySpringBootApplication.class)
public class Test4 {
    @Autowired
    private TreeSelectBuild treeSelectBuild;
    @Test
    public void test1() {
        List<TreeSelect> treeSelects = new ArrayList<>();
        treeSelects.add(new TreeSelect(1l, "顶级节点A",0l));
        treeSelects.add(new TreeSelect(2l, "顶级节点B",0l));
        treeSelects.add(new TreeSelect(3l, "父节点是A",1l));
        treeSelects.add(new TreeSelect(4l, "父节点是B",2l));
        treeSelects.add(new TreeSelect(5l, "父节点是B",2l));
        treeSelects.add(new TreeSelect(6l, "父节点的ID是3",3l));

        List<TreeSelect> treeSelects1 = treeSelectBuild.buildDeptTreeByStream(treeSelects);
        System.out.println(JSON.toJSONString(treeSelects1));
    }
}
复制代码

结果同上

五、Stream流升级实现树形结构

（1）、实体类

复制代码
@Data
public class TreeSelect implements Serializable
{

    /** 节点ID */
    private Long id;

    /** 节点名称 */
    private String label;

    /** 父ID */
    private Long parentId;

    /** 子节点 */
    private List<TreeSelect> children;

    public TreeSelect(Long id, String label, Long parentId) {
        this.id = id;
        this.label = label;
        this.parentId = parentId;
    }

}
复制代码

（2）、实现类

复制代码
@Service
public class TreeSelectBuild {public static List<TreeSelect> buildTree(List<TreeSelect> trees){
        //获取父节点
        List<TreeSelect> collect = trees.stream().filter(m -> m.getParentId() == 0).map(
                (m) -> {
                    m.setChildren(getChildrenList(m, trees));
                    return m;
                }
        ).collect(Collectors.toList());
        return collect;
    }


    /**
     * 获取子节点列表
     * @param tree
     * @param list
     * @return
     */
    public static List<TreeSelect> getChildrenList(TreeSelect tree, List<TreeSelect> list){
        List<TreeSelect> children = list.stream().filter(item -> Objects.equals(item.getParentId(), tree.getId())).map(
                (item) -> {
                    item.setChildren(getChildrenList(item, list));
                    return item;
                }
        ).collect(Collectors.toList());
        return children;
    }

}
复制代码

（3）、测试类

复制代码
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MySpringBootApplication.class)
public class Test5 {
    @Autowired
    private TreeSelectBuild treeSelectBuild;
    @Test
    public void test1() {
        List<TreeSelect> treeSelects = new ArrayList<>();
        treeSelects.add(new TreeSelect(1l, "顶级节点A",0l));
        treeSelects.add(new TreeSelect(2l, "顶级节点B",0l));
        treeSelects.add(new TreeSelect(3l, "父节点是A",1l));
        treeSelects.add(new TreeSelect(4l, "父节点是B",2l));
        treeSelects.add(new TreeSelect(5l, "父节点是B",2l));
        treeSelects.add(new TreeSelect(6l, "父节点的ID是3",3l));
        List<TreeSelect> treeSelects1 = treeSelectBuild.buildTree(treeSelects);
        System.out.println(JSON.toJSONString(treeSelects1));
    }
}
复制代码

结果同上

 


感谢您的阅读，如果您觉得阅读本文对您有帮助，请点一下“推荐”按钮。本文欢迎各位转载，但是转载文章之后必须在文章页面中给出作者和原文连接。
posted on   周文豪  阅读(2179)  评论(0)  编辑  收藏  举报
相关博文：
· 反射：框架设计的灵魂
· JVM优化第三天-tomcat优化
· java-树形结构数据
· 三种方法构建Java树形结构，Stream真的厉害
· java 递归实现树形结构的两种实现方式
阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· .NET10 - 预览版1新功能体验（一）
历史上的今天：
2021-02-27 spring cloud组件之Eureka注册中心:通过自动注册、发现、状态监控来管理服务地址
2021-02-27 高可用的Eureka Server
2021-02-27 springboot整合通用Mapper/tkMapper（4种主键生成方式）
2021-02-27 spring cloud微服务项目工程搭建
Copyright © 2025 周文豪
Powered by .NET 9.0 on Kubernetes Powered by: 博客园
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛