精华内容
下载资源
问答
  • java递归构建树形结构

    万次阅读 2019-02-26 13:50:51
    * 递归算法解析成形结构 * * @param cid * @return * @author jiqinlin */ public TreeNode recursiveTree(int cid) { //根据cid获取节点对象(SELECT * FROM tb_tree t WHERE t.cid=?) TreeNode node = ...

    只有一个根节点数据结构:

    1、准备表结构及对应的表数据
    a、表结构:

    create table TB_TREE
    (
    CID NUMBER not null,
    CNAME VARCHAR2(50),
    PID NUMBER //父节点
    )

    b、表数据:

    复制代码

    insert into tb_tree (CID, CNAME, PID) values (1, '中国', 0);
    insert into tb_tree (CID, CNAME, PID) values (2, '北京市', 1);
    insert into tb_tree (CID, CNAME, PID) values (3, '广东省', 1);
    insert into tb_tree (CID, CNAME, PID) values (4, '上海市', 1);
    insert into tb_tree (CID, CNAME, PID) values (5, '广州市', 3);
    insert into tb_tree (CID, CNAME, PID) values (6, '深圳市', 3);
    insert into tb_tree (CID, CNAME, PID) values (7, '海珠区', 5);
    insert into tb_tree (CID, CNAME, PID) values (8, '天河区', 5);
    insert into tb_tree (CID, CNAME, PID) values (9, '福田区', 6);
    insert into tb_tree (CID, CNAME, PID) values (10, '南山区', 6);
    insert into tb_tree (CID, CNAME, PID) values (11, '密云县', 2);
    insert into tb_tree (CID, CNAME, PID) values (12, '浦东', 4);

    复制代码

    2、TreeNode对象,对应tb_tree

    复制代码

    public class TreeNode implements Serializable {
    private Integer cid;
    private String cname;
    private Integer pid;
    private List nodes = new ArrayList();
     
    public TreeNode() {
    }
     
    //getter、setter省略
    }

    复制代码

    3、测试数据

    复制代码

    public class TreeNodeTest {
    @Test
    public void loadTree() throws Exception{
    System.out.println(JsonUtils.javaToJson(recursiveTree(1)));
    }
     
    /**
    * 递归算法解析成树形结构
    *
    * @param cid
    * @return
    * @author jiqinlin
    */
    public TreeNode recursiveTree(int cid) {
    //根据cid获取节点对象(SELECT * FROM tb_tree t WHERE t.cid=?)
    TreeNode node = personService.getreeNode(cid);
    //查询cid下的所有子节点(SELECT * FROM tb_tree t WHERE t.pid=?)
    List childTreeNodes = personService.queryTreeNode(cid); 
    //遍历子节点
    for(TreeNode child : childTreeNodes){
    TreeNode n = recursiveTree(child.getCid()); //递归
    node.getNodes().add(n);
    }
     
    return node;
    }
    }

    复制代码

    输出的json格式如下:

    复制代码

    {
        "cid": 1,
        "nodes": [
            {
                "cid": 2,
                "nodes": [
                    {
                        "cid": 11,
                        "nodes": [
                             
                        ],
                        "cname": "密云县",
                        "pid": 2
                    }
                ],
                "cname": "北京市",
                "pid": 1
            },
            {
                "cid": 3,
                "nodes": [
                    {
                        "cid": 5,
                        "nodes": [
                            {
                                "cid": 7,
                                "nodes": [
                                     
                                ],
                                "cname": "海珠区",
                                "pid": 5
                            },
                            {
                                "cid": 8,
                                "nodes": [
                                     
                                ],
                                "cname": "天河区",
                                "pid": 5
                            }
                        ],
                        "cname": "广州市",
                        "pid": 3
                    },
                    {
                        "cid": 6,
                        "nodes": [
                            {
                                "cid": 9,
                                "nodes": [
                                     
                                ],
                                "cname": "福田区",
                                "pid": 6
                            },
                            {
                                "cid": 10,
                                "nodes": [
                                     
                                ],
                                "cname": "南山区",
                                "pid": 6
                            }
                        ],
                        "cname": "深圳市",
                        "pid": 3
                    }
                ],
                "cname": "广东省",
                "pid": 1
            },
            {
                "cid": 4,
                "nodes": [
                    {
                        "cid": 12,
                        "nodes": [
                             
                        ],
                        "cname": "浦东",
                        "pid": 4
                    }
                ],
                "cname": "上海市",
                "pid": 1
            }
        ],
        "cname": "中国",
        "pid": 0
    }

    有多个根节点的树形结构:

    package com.forchain.platform.model;
    
    import javax.persistence.*;
    
    @Table(name = "tb_tree")
    public class TbTree {
    
        @Id
        private Long cid;
    
        @Column(name = "CNAME")
        private String cname;
    
        @Column(name = "PID")
        private Long pid;
    
        /**
         * @return CID
         */
        public Long getCid() {
            return cid;
        }
    
        /**
         * @param cid
         */
        public void setCid(Long cid) {
            this.cid = cid;
        }
    
        /**
         * @return CNAME
         */
        public String getCname() {
            return cname;
        }
    
        /**
         * @param cname
         */
        public void setCname(String cname) {
            this.cname = cname;
        }
    
        /**
         * @return PID
         */
        public Long getPid() {
            return pid;
        }
    
        /**
         * @param pid
         */
        public void setPid(Long pid) {
            this.pid = pid;
        }
    }
    /**
     * author   chong
     * 创建日期: 2019/2/26
     * 创建时间: 12:35
     */
    @Getter
    @Setter
    public class TreeNode extends TbTree implements Serializable {
    
        List<List<TreeNode>> nodeList = new ArrayList<>();
    
    }
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.forchain.platform.mapper.TbTreeMapper">
      <resultMap id="BaseResultMap" type="com.forchain.platform.model.TbTree">
        <!--
          WARNING - @mbg.generated
        -->
        <result column="CID" jdbcType="BIGINT" property="cid" />
        <result column="CNAME" jdbcType="VARCHAR" property="cname" />
        <result column="PID" jdbcType="BIGINT" property="pid" />
      </resultMap>
      <select id="queryTreeNode" parameterType="java.lang.Long" resultType="com.forchain.platform.model.TreeNode">
        select * from tb_tree where PID =#{pId}
      </select>
    </mapper>
    package com.forchain.platform.mapper;
    
    import com.forchain.platform.config.mapper.BaseMapper;
    import com.forchain.platform.model.TbTree;
    import com.forchain.platform.model.TreeNode;
    
    import java.util.List;
    
    public interface TbTreeMapper extends BaseMapper<TbTree> {
    
        List<TreeNode> queryTreeNode(Long pId);
    
    }

    create table tb_tree
    (
    CID BIGINT not null,
    CNAME VARCHAR(50),
    PID BIGINT
    )

    insert into tb_tree (CID, CNAME, PID) values (1, '中国', NULL);
    insert into tb_tree (CID, CNAME, PID) values (2, '北京市', NULL);
    insert into tb_tree (CID, CNAME, PID) values (3, '广东省', NULL);
    insert into tb_tree (CID, CNAME, PID) values (4, '上海市', 1);
    insert into tb_tree (CID, CNAME, PID) values (5, '广州市', 1);
    insert into tb_tree (CID, CNAME, PID) values (6, '深圳市', 1);
    insert into tb_tree (CID, CNAME, PID) values (7, '海珠区', 1);
    insert into tb_tree (CID, CNAME, PID) values (8, '天河区', 2);
    insert into tb_tree (CID, CNAME, PID) values (9, '福田区', 2);
    insert into tb_tree (CID, CNAME, PID) values (10, '南山区', 3);
    insert into tb_tree (CID, CNAME, PID) values (11, '密云县', 3);
    insert into tb_tree (CID, CNAME, PID) values (12, '浦东', 3);
    insert into tb_tree (CID, CNAME, PID) values (13, '浦东22', 3);
    insert into tb_tree (CID, CNAME, PID) values (14, '浦东23', 4);
    insert into tb_tree (CID, CNAME, PID) values (15, '浦东24', 4);
    insert into tb_tree (CID, CNAME, PID) values (16, '浦东25', 6);
    insert into tb_tree (CID, CNAME, PID) values (17, '浦东25', 6);
    insert into tb_tree (CID, CNAME, PID) values (18, '浦东25', 6);

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class BcHrPlatformTest {
    
        @Resource
        TbTreeMapper tbTreeMapper;
        @Test
        public void loadTree() {
            System.err.println(JSONObject.toJSONString(recursiveTree(Long.parseLong(String.valueOf(0)))));
        }
    
        /**
         * 递归算法解析成树形结构
         */
        public List<TreeNode> recursiveTree(Long pId) {
            List<TreeNode> treeNodes = tbTreeMapper.queryTreeNode(pId);
            for (TreeNode node:treeNodes) {
                List<TreeNode> treeNodes1 = recursiveTree(node.getCid());
                if (!treeNodes1.isEmpty()) {
                    node.getNodeList().add(treeNodes1);
                }
            }
            return treeNodes;
        }
    }

    [{
        "cid": 1,
        "cname": "中国",
        "nodeList": [
            [{
                "cid": 4,
                "cname": "上海市",
                "nodeList": [
                    [{
                        "cid": 14,
                        "cname": "浦东23",
                        "nodeList": [],
                        "pid": 4
                    }, {
                        "cid": 15,
                        "cname": "浦东24",
                        "nodeList": [],
                        "pid": 4
                    }]
                ],
                "pid": 1
            }, {
                "cid": 5,
                "cname": "广州市",
                "nodeList": [],
                "pid": 1
            }, {
                "cid": 6,
                "cname": "深圳市",
                "nodeList": [
                    [{
                        "cid": 16,
                        "cname": "浦东25",
                        "nodeList": [],
                        "pid": 6
                    }, {
                        "cid": 17,
                        "cname": "浦东25",
                        "nodeList": [],
                        "pid": 6
                    }, {
                        "cid": 18,
                        "cname": "浦东25",
                        "nodeList": [],
                        "pid": 6
                    }]
                ],
                "pid": 1
            }, {
                "cid": 7,
                "cname": "海珠区",
                "nodeList": [],
                "pid": 1
            }]
        ],
        "pid": 0
    }, {
        "cid": 2,
        "cname": "北京市",
        "nodeList": [
            [{
                "cid": 8,
                "cname": "天河区",
                "nodeList": [],
                "pid": 2
            }, {
                "cid": 9,
                "cname": "福田区",
                "nodeList": [],
                "pid": 2
            }]
        ],
        "pid": 0
    }, {
        "cid": 3,
        "cname": "广东省",
        "nodeList": [
            [{
                "cid": 10,
                "cname": "南山区",
                "nodeList": [],
                "pid": 3
            }, {
                "cid": 11,
                "cname": "密云县",
                "nodeList": [],
                "pid": 3
            }, {
                "cid": 12,
                "cname": "浦东",
                "nodeList": [],
                "pid": 3
            }, {
                "cid": 13,
                "cname": "浦东22",
                "nodeList": [],
                "pid": 3
            }]
        ],
        "pid": 0
    }]

    展开全文
  • Java递归构建树形数据结构实现多级树形菜单展示

    万次阅读 热门讨论 2018-06-15 17:46:16
    首先看看需求,形菜单是这样的:根据需求创建数据模型:构造形数据结构:转为json数据看看结构是否正确:打完收工!

    首先看看需求,树形菜单是这样的:


    根据需求创建数据模型:


    构造树形数据结构(Java8环境,Maps和Lists是用了谷歌的guava包):



    转为json数据看看结构是否正确:



    打完收工!



    2018-06-09修改,过滤map改为set



    展开全文
  • java 不使用递归构建树形结构基本结构对象树形结构对象构建方法 一般树形结构都包含两个关键字段,parentId,children,我的例子中使用的是parent对象,实际使用自己更改即可。 基本结构对象 public class TreeBase<...

    java 不使用递归构建树形结构

    一般树形结构都包含两个关键字段,parentId,children,我的例子中使用的是parent对象,实际使用自己更改即可。

    基本结构对象

    public class TreeBase<T> {
        @ApiModelProperty(value = "子集")
        private List<T> children;
        
        @ApiModelProperty(value = "父级id")
        private T parent;
    	
    	@ApiModelProperty(value = "id")
    	private Long id;
    }
    

    上面这组对象是树形结构的基本结构,如果使用的父级结构是parentId就把 private T parent;改成pring String parentId;即可,另外,只要继承了该结构的对象,都可以调用下面的方法构建树形结构

    树形结构对象

    public class Permission extends TreeBase<Permission> {
    
        .....
        字段无需理会,实际使用不到
        .....
    
    }
    

    这是需要构建树形结构的对象,直接继承即可

    构建方法

     public <T extends TreeBase<T>> List<T> listToTree(List<T> tList) {
            List<T> firstLabelDto = new ArrayList<>();
            Map<Long, T> labelMap = tList.stream().collect(Collectors.toMap(T::getId, v->v,(v1, v2)->v1));//将递归对象转化成map,方便查询
            for (T t : tList) {
                if (t.getParent() == null) {
                    firstLabelDto.add(t);
                }
                else {
                    labelMap.get(t.getParent().getId()).getChildren().add(t);
                }
            }
            return firstLabelDto;
        }
    

    如果使用的是parentId,则在使用parent的位置相应更改即可,使用时直接调用,返回结果就是完整的树形结构

    展开全文
  • 定义一个实体 @Data public class Tree<T> { /** * 节点ID */ private String id; /** * 节点的子节点 */ private List<Tree<T>> children = new ArrayList<>(); /** * 父ID ...

    定义一个树实体

    @Data
    public class Tree<T> {
        /**
         * 节点ID
         */
        private String id;
        /**
         * 节点的子节点
         */
        private List<Tree<T>> children = new ArrayList<>();
    
        /**
         * 父ID
         */
        private String parentId;
         /**
         * 显示节点文本
         */
        private String text;
    

    树工具类

    package com.yl.util.tree;
    
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    public class TreeUtil {
    
       /**
        * 使用递归方法建树
        *
        * @param modules
        * @return
        */
       public static <T> List<Tree<T>> buildByRecursive(List<Tree<T>> modules, String pId) {
           List<Tree<T>> trees = new ArrayList<>();
           for (Tree<T> treeNode : modules) {
               if (pId.equals(treeNode.getParentId())) {
                   trees.add(findChildren(treeNode, modules));
               }
           }
    
           return trees;
       }
    
       /**
        * 递归查找子节点
        *
        * @param treeNodes
        * @return
        */
       public static <T> Tree<T> findChildren(Tree<T> treeNode, List<Tree<T>> nodes) {
           for (Tree<T> it : nodes) {
               if (treeNode.getId().equals(it.getParentId())) {
                   if (treeNode.getChildren() == null) {
                       treeNode.setChildren(new ArrayList<>());
                   }
                   treeNode.getChildren().add(findChildren(it, nodes));
               }
           }
           return treeNode;
       }
    }
    

    调用

    public List<Tree<NoticeType>> getTree() {
            List<Tree<NoticeType>> trees = new ArrayList<>();
            List<NoticeType> list = noticeTypeMapper.selectAll();
            buildTrees(trees,list);
            return TreeUtil.buildByRecursive(trees,"0");
        }
    
        private void buildTrees(List<Tree<NoticeType>> trees,List<NoticeType> noticeTypes){
            noticeTypes.forEach(noticeTypes -> {
                Tree<NoticeType> tree = new Tree<>();
                tree.setId(noticeTypes.getId().toString());
                tree.setParentId(noticeTypes.getParentId().toString());
                tree.setText(noticeTypes.getName());
                trees.add(tree);
            });
        }
    
    展开全文
  • java-递归构建目录结构 注意:实体中需要有一个属性判断当前节点是否含有孩子节点,递归方法会根据该标识停止,该属性一旦有误将会陷入死循环 public List<EffectEvaluation> getEffectEvaluationTree...
  • java递归语法使用java递归语法使用node类使用递归方法建树 java递归语法使用 你好! node实体类递归建tree。 node类 @Data public class TIotSysArea { private Long id; private String name; private String...
  • //转换对象 //根节点 List<AynpTree> treeRootList = (List) CollectionUtils.select(dataList, new Predicate() { @Override public boolean evaluate(Object object) { AynpTree ay = (AynpTree) ...
  • java 递归实现权限(菜单

    千次阅读 多人点赞 2019-12-18 17:56:12
    java 递归实现权限(菜单)省市县多级结构
  • Java递归算法构造JSON形结构,Java递归算法构造JSON形结构Java递归算法构造JSON形结构
  • 递归构建一整棵

    2018-07-24 11:26:57
    通过递归方法构建树形结构数据,比如无限层级菜单,可供新手学习递归算法
  • 项目开发中,几乎无法避免的会遇到形结构,今天和大家分享java后端如何处理数据为形结构。 前端处理形结构,后端生成形结构。 Entity实体层: 此处省略好几个实体字段。 /** * 孩子节点集合 */ ...
  • 请跟着main方法走,然后看代码注释。...import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.ut...
  • java递归生成菜单

    2020-06-04 16:57:50
    递归组装形结构函数实现 mysql表 数据自行准备 CREATE TABLE `sys_menu` ( `id` int(11) NOT NULL AUTO_INCREMENT, `pid` bigint(20) DEFAULT NULL, `title` varchar(255) CHARACTER SET utf8 DEFAULT NULL...
  • JavaScript 递归构建树状图(根据parentId) 类似于实现这样的效果 实现思路: 第一步:找到所有根节点(parentId == null) 第二步:遍历跟结点,递归生成根节点的子树 1.1 JavaScript 实现 export class ...
  • JAVA递归生成tree

    千次阅读 2015-06-01 09:37:46
    关于类别的多级是一个刚接触ajax和多级类别很头痛的问题,针对那种商品种类繁多,级别层次多更是麻烦的问题,去年刚学asp.net,实验室的同学曾经这样做过,递归sql,现在看了惊心动魄 虽然实现了类别多级的问题这样...
  • 递归构建组织

    2015-10-22 17:29:22
    /** * output package name */ package com.kingdee.eas.testunit.client; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.log4j.Log
  • java—stream流递归实现形结构

    千次阅读 2020-09-28 18:49:38
    stream流递归实现形结构
  • java+mysql递归拼接形JSON列表

    万次阅读 2017-05-26 13:52:52
    java+mysql递归拼接形JSON列表
  • 要删除形结构的节点,需考虑两件事: 1.要删除的节点若包含子节点,则需删除...要遍历形结构中的一个节点及其子节点,采用递归会比较方便,首先需要一个方法,来将这两件事包含在一起,于是要构建一个方法delClasse

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,154
精华内容 18,461
关键字:

java递归构建树

java 订阅