java构建树形结构

我不是女神ヾ 2023-10-07 22:00 41阅读 0赞

**目录**

前言

实现树形结构

一.树节点数据类(反回参数类)

二.给树形结构添加数据

三.测试类

四.测试结果

--------------------

## 前言 ##

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

图:

![a0cf216c17e64031b1be9a8df274f7b2.png][]

## 实现树形结构 ##

### 一.树节点数据类(反回参数类) ###

@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常用递归方法 ####

思路:

1、首先获取所有的根节点（顶级节点），即根节点的parentId = 0。  
2、根据每一个根节点，与所有节点集合（数据）进行判断，当前节点是否为其下的子节点。  
3、若是，则递归调用构建树形；若不是，则表明该节点不属于其下子节点。  
4、应继续循环判断节点父子关系，直到所有节点与根节点判断完毕。

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){
            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;
        }
     
    }

#### 2.2.stream方法获取树形结构 ####

public List<TreeNode> getTree(){
    // 模拟测试数据（通常为数据库的查询结果）
            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"));
    //过滤顶级id
    List<TreeNode> collect = treeNodeList.stream().filter(item -> item.getParentId() != 0).collect(Collectors.toList());
    //通过父级id进行分组 获取我们的"List<TreeNode> children"子节点
     Map<Integer, List<TreeNode>> map = treeNodeList.stream().collect(Collectors.groupingBy(TreeNode::getParentId));
    getChildrenTree(collect,map)
    return collect;
    }
    
    public static void getChildrenTree(List<TreeNode> collect, Map<Integer, List<TreeNode>> map) {
            for (TreeNode treeNode : collect) {
                List<TreeNode> childList = map.get(treeNode.getId());
                treeNode.setChildren(childList);
            }

### 三.测试类 ###

注意: 返回值有可能请求不出来, 需要循环, 这里我们的返回参数不太一样

@Test
        List<TreeNode> contextLoads() {
    
            // 模拟测试数据（通常为数据库的查询结果）
            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();
            return treeNodeList;
        }

### 四.测试结果 ###

![659f034dd93540d5a174bd562c9b9aeb.png][]

[Link 1]: https://so.csdn.net/so/search?q=%E6%A0%91%E5%BD%A2%E7%BB%93%E6%9E%84&spm=1001.2101.3001.7020
[a0cf216c17e64031b1be9a8df274f7b2.png]: https://img-blog.csdnimg.cn/a0cf216c17e64031b1be9a8df274f7b2.png
[659f034dd93540d5a174bd562c9b9aeb.png]: https://img-blog.csdnimg.cn/659f034dd93540d5a174bd562c9b9aeb.png