Java编程：将具有父子关系的数据库表数据转换为树形结构，支持无限层级

最新推荐文章于 2024-09-16 13:25:44 发布
最新推荐文章于 2024-09-16 13:25:44 发布
阅读量2.6w 收藏 63
点赞数 9
分类专栏： Java编程 文章标签： 树形结构编程 父子关系的树 无限层级 Tree TreeNode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/claram/article/details/54616485
版权

在平时的开发工作中，经常遇到这样一个场景，在数据库中存储了具有父子关系的数据，需要将这些数据以树形结构的形式在界面上进行展示。本文的目的是提供了一个通用的编程模型，解决将具有父子关系的数据转换成树形结构的问题。如有不正之处，欢迎大家批评指正。

编程模型

我们以北京行政区划为例，讲解整个模型。

北京市：市辖区 县

市辖区：东城区 西城区 朝阳区 丰台区 石景山区 海淀区 门头沟区 房山区 通州区 顺义区 昌平区 大兴区 怀柔区 平谷区

县：密云县 延庆县

UML类图如下：

Tree结构

TreeNode:定义树的节点对象

  • nodeId：树节点Id。
  • nodeName：树节点名称。
  • parentNodeId：树节点父Id。
  • orderNum：节点在树中的排序号，在同一节点下进行排序。
  • level：当前树节点所在的层级，根节点为第一层。
  • parent：当前树节点的父节点。
  • children：当前树节点的儿子节点。
  • allChildren：当前树节点的子孙节点。

ITree：定义树对象要实现的方法。

  • getTree()：以 List 形式返回树的所有的 TreeNode 对象。
  • getRoot()：以 List 形式返回树的根节点，可能是一个或者多个。
  • getTreeNode(String nodeId)：根据 nodeId 返回对应的 TreeNode 对象。

Tree：实现 ITree 接口，提供树的完整功能。

  • getTree()：以 List 形式返回树的所有的 TreeNode 对象。
  • getRoot()：以 List 形式返回树的根节点，可能是一个或者多个。
  • getTreeNode(String nodeId)：根据 nodeId 返回对应的 TreeNode 对象。

ITreeNode：定义模板方法，构造树形结构的类要实现该接口，Tree 通过调用该接口中的方法获取 nodeId nodeName parentNodeId orderNum 数据。

  • getNodeId()：获取树节点Id。
  • getNodeName()：获取树节点名称。
  • getParentNodeId()：获取树节点父Id。
  • getOrderNum()：获取节点在树中的排序号，在同一节点下进行排序。

Org：定义行政区划类，实现 ItreeNode 接口。

实现代码

TreeNode类：

package com.ips.tree;

import java.util.ArrayList;
import java.util.List;

import com.alibaba.fastjson.annotation.JSONField;

/**
 * <p>Title: 树节点</p>
 * <p>Description:一棵树由许多包含父子关系的节点组成 </p>
 * @author  liuzhibo
 * @date    2017年1月18日
 */
public class TreeNode {
    //树节点ID
    @JSONField(ordinal=1)
    private String nodeId;
    //树节点名称
    @JSONField(ordinal=2)
    private String nodeName;
    //父节点ID
    @JSONField(ordinal=3)
    private String parentNodeId;
    //节点在树中的排序号
    @JSONField(ordinal=4)
    private int orderNum;
    //节点所在的层级
    @JSONField(ordinal=5)
    private int level;
    private TreeNode parent;
    //当前节点的二子节点
    @JSONField(ordinal=6)
    private List<TreeNode> children = new ArrayList<TreeNode>();
    //当前节点的子孙节点
    private List<TreeNode> allChildren = new ArrayList<TreeNode>();

    public TreeNode(ITreeNode obj){
        this.nodeId = obj.getNodeId();
        this.nodeName = obj.getNodeName();
        this.parentNodeId = obj.getNodeParentId();
        this.orderNum = obj.getOrderNum();
    }
    public void addChild(TreeNode treeNode){
        this.children.add(treeNode);
    }
    public void removeChild(TreeNode treeNode){
        this.children.remove(treeNode);
    }
    public String getNodeId() {
        return nodeId;
    }
    public void setNodeId(String nodeId) {
        this.nodeId = nodeId;
    }
    public String getNodeName() {
        return nodeName;
    }
    public void setNodeName(String nodeName) {
        this.nodeName = nodeName;
    }
    public String getParentNodeId() {
        return parentNodeId;
    }
    public void setParentNodeId(String parentNodeId) {
        this.parentNodeId = parentNodeId;
    }
    public int getLevel() {
        return level;
    }
    public void setLevel(int level) {
        this.level = level;
    }
    public TreeNode getParent() {
        return parent;
    }
    public void setParent(TreeNode parent) {
        this.parent = parent;
    }
    public List<TreeNode> getChildren() {
        return children;
    }
    public void setChildren(List<TreeNode> children) {
        this.children = children;
    }
    public int getOrderNum() {
        return orderNum;
    }
    public void setOrderNum(int orderNum) {
        this.orderNum = orderNum;
    }

    public List<TreeNode> getAllChildren() {
        if(this.allChildren.isEmpty()){
            for(TreeNode treeNode : this.children){
                this.allChildren.add(treeNode);
                this.allChildren.addAll(treeNode.getAllChildren());
            }
        }
        return this.allChildren;
    }   
}

ITree接口：

package com.ips.tree;

import java.util.List;

public interface ITree {
    public List<TreeNode> getTree();
    public List<TreeNode> getRoot();
    public TreeNode getTreeNode(String nodeId);
}

Tree类：

package com.ips.tree;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

public class Tree implements ITree {
    private HashMap<String, TreeNode> treeNodesMap = new HashMap<String, TreeNode>();
    private List<TreeNode> treeNodesList = new ArrayList<TreeNode>();

    public Tree(List<ITreeNode> list){
        initTreeNodeMap(list);
        initTreeNodeList();
    }

    private void initTreeNodeMap(List<ITreeNode> list){
        TreeNode treeNode = null;
        for(ITreeNode item : list){
            treeNode = new TreeNode(item);
            treeNodesMap.put(treeNode.getNodeId(), treeNode);
        }

        Iterator<TreeNode> iter = treeNodesMap.values().iterator();
        TreeNode parentTreeNode = null;
        while(iter.hasNext()){
            treeNode = iter.next();
            if(treeNode.getParentNodeId() == null || treeNode.getParentNodeId() == ""){
                continue;
            }

            parentTreeNode = treeNodesMap.get(treeNode.getParentNodeId());
            if(parentTreeNode != null){
                treeNode.setParent(parentTreeNode);
                parentTreeNode.addChild(treeNode);
            }
        }
    }

    private void initTreeNodeList(){
        if(treeNodesList.size() > 0){
            return;
        }
        if(treeNodesMap.size() == 0){
            return;
        }
        Iterator<TreeNode> iter = treeNodesMap.values().iterator();
        TreeNode treeNode = null;
        while(iter.hasNext()){
            treeNode = iter.next();
            if(treeNode.getParent() == null){
                this.treeNodesList.add(treeNode);
                this.treeNodesList.addAll(treeNode.getAllChildren());
            }
        }
    }

    @Override
    public List<TreeNode> getTree() {
        return this.treeNodesList;
    }

    @Override
    public List<TreeNode> getRoot() {
        List<TreeNode> rootList = new ArrayList<TreeNode>();
        if (this.treeNodesList.size() > 0) {
            for (TreeNode node : treeNodesList) {
                if (node.getParent() == null)
                    rootList.add(node);
            }
        }
        return rootList;
    }

    @Override
    public TreeNode getTreeNode(String nodeId) {
        return this.treeNodesMap.get(nodeId);
    }

}

ITreeNode 接口：

package com.ips.tree;

public interface ITreeNode {
    public String getNodeId();
    public String getNodeName();
    public String getNodeParentId();
    public Integer getOrderNum();
}

Org 类：

package com.ips.tree;

public class Org implements ITreeNode {
    private String uuid;
    private String parentId;
    private String name;
    private Integer orderNum;
    private String code;
    private String type;

    public Org(){

    }
    public Org(String uuid, String parentId, String name, Integer orderNum, String code, String type){
        this.uuid = uuid;
        this.parentId = parentId;
        this.name = name;
        this.orderNum = orderNum;
        this.code = code;
        this.type = type;
    }
    @Override
    public String getNodeId() {
        return this.uuid;
    }

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

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

    @Override
    public Integer getOrderNum() {
        return this.orderNum;
    }

    public String getUuid() {
        return uuid;
    }

    public void setUuid(String uuid) {
        this.uuid = uuid;
    }

    public String getParentId() {
        return parentId;
    }

    public void setParentId(String parentId) {
        this.parentId = parentId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
    public void setOrderNum(Integer orderNum) {
        this.orderNum = orderNum;
    }

}

TreeDemo 类：执行该类的 main 方法，查看效果。

package com.ips.tree;

import java.util.ArrayList;
import java.util.List;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SimplePropertyPreFilter;

public class TreeDemo {

    public static void main(String[] args) {
        Tree tree = new Tree(genOrgList());
        TreeNode treeNode = tree.getTreeNode("2");

        SimplePropertyPreFilter filter = new SimplePropertyPreFilter(); // 构造方法里，也可以直接传需要序列化的属性名字
        filter.getExcludes().add("parent");
        filter.getExcludes().add("allChildren");
        String data = JSONObject.toJSONString(treeNode, filter);
        System.out.println(data);
    }

    public static List<ITreeNode> genOrgList(){
        List<ITreeNode> list = new ArrayList<ITreeNode>();

        Org org = new Org("2", "1", "北京市", 2, "110000", "2");
        list.add(org);
        org = new Org("3", "2", "市辖区", 3, "110100", "3");
        list.add(org);
        org = new Org("4", "3", "东城区", 4, "110101", "4");
        list.add(org);
        org = new Org("5", "3", "东城区", 5, "110102", "4");
        list.add(org);
        org = new Org("6", "3", "东城区", 6, "110105", "4");
        list.add(org);
        org = new Org("7", "3", "东城区", 7, "110106", "4");
        list.add(org);
        org = new Org("8", "3", "东城区", 8, "110107", "4");
        list.add(org);
        org = new Org("9", "3", "东城区", 9, "110108", "4");
        list.add(org);
        org = new Org("10", "3", "东城区", 10, "110109", "4");
        list.add(org);
        org = new Org("11", "3", "东城区", 11, "110111", "4");
        list.add(org);
        org = new Org("12", "3", "东城区", 12, "110112", "4");
        list.add(org);
        org = new Org("13", "3", "东城区", 13, "110113", "4");
        list.add(org);
        org = new Org("14", "3", "东城区", 14, "110114", "4");
        list.add(org);
        org = new Org("15", "3", "东城区", 15, "110115", "4");
        list.add(org);
        org = new Org("16", "3", "东城区", 16, "110116", "4");
        list.add(org);
        org = new Org("17", "3", "东城区", 17, "110117", "4");
        list.add(org);
        org = new Org("18", "2", "县", 3, "110200", "3");
        list.add(org);
        org = new Org("19", "18", "密云县", 19, "110228", "4");
        list.add(org);
        org = new Org("20", "18", "延庆县", 20, "110229", "4");
        list.add(org);
        return list;
    }

}

执行结果如下：

{
    "nodeId": "2",
    "nodeName": "北京市",
    "parentNodeId": "1",
    "orderNum": 2,
    "level": 0,
    "children": [{
        "nodeId": "18",
        "nodeName": "县",
        "parentNodeId": "2",
        "orderNum": 3,
        "level": 0,
        "children": [{
            "nodeId": "19",
            "nodeName": "密云县",
            "parentNodeId": "18",
            "orderNum": 19,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "20",
            "nodeName": "延庆县",
            "parentNodeId": "18",
            "orderNum": 20,
            "level": 0,
            "children": []
        }]
    },
    {
        "nodeId": "3",
        "nodeName": "市辖区",
        "parentNodeId": "2",
        "orderNum": 3,
        "level": 0,
        "children": [{
            "nodeId": "17",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 17,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "15",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 15,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "16",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 16,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "13",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 13,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "14",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 14,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "11",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 11,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "12",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 12,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "10",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 10,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "7",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 7,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "6",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 6,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "5",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 5,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "4",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 4,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "9",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 9,
            "level": 0,
            "children": []
        },
        {
            "nodeId": "8",
            "nodeName": "东城区",
            "parentNodeId": "3",
            "orderNum": 8,
            "level": 0,
            "children": []
        }]
    }]
}

注：该示例中使用了 alibaba 的 fastjson 实现类对象序列化，maven 依赖如下：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.20</version>
</dependency>
志波同学
关注
专栏目录
json mysql 树状_从数据库取出自关联数据后，递归成树形json
weixin_34380880的博客
01-27 435
功能需求：从数据库里取出带有id和父级id关系的表里的全部数据，经过服务端处理成树形分层的json，返回给前端插件显示多级结构。核心步骤：将取出的数据根据每行的id处理成相同格式的数组形式以后进行递归，没有父级id的作为根节点层，有父级id的讲自己写为父级的子级层示例如下：var getRiskJson = function (data,callback){console.log("getRisk...
java后端将非树型结构的机构数据转换为树形结构的机构数据示例
qq_38127559的博客
02-18 1140
统计平台项目，后端采用一套开源框架，框架内封装了完善的用户、角色、菜单、组织机构、数据字典等基础功能，支持访问授权、按钮权限、数据权限等。新系统的这部分基础数据，完全来源甲方原有老系统。新系统的组织机构设计采用树形结构，而甲方现有系统的机构数据并非树型结构。为了将现有系统的机构数据导入到新系统中，支持统计平台的机构管理，需要写一套转换程序，将非树型结构的机构信息转为树型结构导入到统计平台中。具体过程如下所示。
多表之间存在父子级关系：根据某一级，查询所有子级 & 构建树结构数据（巧妙）
pscool的博客
11-16 469
表park_project、park_project_sub 、building 、building_floor 、building_floor_room 存在父子级关系，并且确定是4层，现需要。如上查询完成后，可在代码里针对查询出来的每条数据，根据当前查询的位置类型，作对应的处理。在mybatisplus中拼接上and (条件1 or 条件2 or 条件3 …
存储数据的树形结构
最新发布
weixin_71454352的博客
09-16 890
存储数据的树形结构
Java 将有父子关系的数据转换成树形结构数据
Charge8的博客
02-15 8985
一、数据库父子结构数据设计 大部分采用parentId的形式来存储父id，并且只存储父id，祖父Id不存储。也可以添加存储层级级别或者层级关系等字段。 CREATE TABLE `t_resource` ( `id` varchar(255) NOT NULL COMMENT '主键', `parent_id` varchar(255) DEFAULT NULL COMMEN...
【Java 进阶篇】使用 Stream 流和 Lambda 组装复杂父子树形结构（List 集合形式）
sinat_53467514的博客
01-20 1559
在最近的开发中，一星期内遇到了两个类似的需求：返回组装好的部门树、返回组装好的地区信息树，最终都需要返回 List 集合对象给前端。于是在经过需求分析和探索实践后，我对于这种基于 Stream 和 List 结构的父、子树形结构的操作有了新的认识，现在拿出来和大家作分享交流。一般来说完成这样的需求大多数人会想到递归，但递归的方式弊端过于明显：方法多次自调用效率很低、数据量大容易导致堆栈溢出、随着树深度的增加其时间复杂度会呈指数级增加等。一次数据库查询全部数据（几万条），其它全是内存操作、性能高；
java父子节点parentid树形结构数据规整
caileigood的博客
04-30 8803
这几天写一个父子节点的数据规整，在网上找了一些方法，都太繁琐，自己写了一个，感觉比较简单，分享给大家 先说一下原理 第一，我们从数据库中将需要的数据查询出来，得到一个Object集合的list 第二，定义一个map，key为id，value为Object，这个的目的是为了方便后面的查找 第三，遍历第一步中查询到的数据集合list，取出Object中的parentid，根据parentid从...
如何将父子关系的数据转化为树形结构的数组
haishangfeie的博客
07-22 3690
本文主要介绍了一种将父子关系转为树形结构数组的思路、原理以及方法。
基于JAVA建立树形结构的算法优化.pdf
07-02
树形结构是一种在计算机科学和数据管理中广泛应用的非线性数据结构，它模拟了现实世界中实体之间的层级关系，例如公司的组织结构、计算机文件系统的目录结构等。树形结构在程序设计中极为重要，尤其是在需要展示层级...
java实现多层嵌套循环参数转换
06-20
在Java编程中，多层嵌套循环是一种常见的数据处理方式，尤其在处理具有层次关系的数据时，例如构建或解析父子级结构。在这种场景下，我们可能需要遍历多个层级的数据，以便进行转换、操作或者存储到数据库中。下面将...
Java将包含子父级关系的集合转换为树形集合
tony_stark的博客
07-16 1059
1.创建树形工具接口 import java.util.List; /** * 树形工具接口 * * @author Tom * @data 2021-07-16 * @param <T> */ public interface TreeNode<T> { Long getId(); Long getParentId(); T getParent(); T setParent(T parent); List<?
把具有父子关系的数据组装成树状结构
Yuwen_forJava的博客
06-16 639
需求：把具有父子关系的数据组装成树状结构 实体类： @Data public class CategoryVo { /** * 类别Id */ private Integer id; /** * 父类别id当id=0时说明是根节点,一级类别 */ private Integer parentId; /** * 子类目 */ private List<CategoryVo> s
父子节点列表转成树形结构
qq_31564573的博客
06-13 1364
父子节点列表转成树形结构
Java递归/遍历，实现遍历父子级菜单
weixin_67573348的博客
02-20 1278
【代码】Javai递归实现遍历父子级菜单。
java父子表_Java编程：将具有父子关系的数据库表数据转换为树形结构，支持无限层级...
weixin_36374105的博客
02-24 968
在平时的开发工作中，经常遇到这样一个场景，在数据库中存储了具有父子关系的数据，需要将这些数据以树形结构的形式在界面上进行展示。本文的目的是提供了一个通用的编程模型，解决将具有父子关系的数据转换成树形结构的问题。如有不正之处，欢迎大家批评指正。编程模型我们以北京行政区划为例，讲解整个模型。北京市：市辖区 县市辖区：东城区 西城区 朝阳区 丰台区 石景山区 海淀区 门头沟区 房山区 通州区 顺义区 昌...
MySQL 中两张表主键自增时，Java 后端组成树形结构的解决办法 ...
weixin_34114823的博客
04-22 276
场景 当需要将两张不同表的数据进行合并处理，并且两张表的主键均为自增，主键同是数字。这时候需要区分的、不同的表进行取值，可以使其中一张表的主键为负数，即-1，-2，-3。 当需要把取出来的两张表分别再存进数据库时，要将之前取值是负数的主键转为正数，而转为正数的方式也很简单，也就是负负得正，即(-(-1)) = 1 具体示例 将系统表和菜单表的数据组合成树...
Java实现数据库配置中父子级结构的多层参数转换方法
在Java中，多层嵌套循环通常用于处理复杂的数据结构，例如树形结构或者层级数据，其中参数转换涉及到数据类型、格式以及内容的转换。我们将通过分析提供的Java实现文件`InterfaceAuthManageServiceImpl.java`和...
如何将具有父子关系的数据快速变成树结构
weixin_34344403的博客
02-19 2169
在实际项目中，经常会碰到类似的场景，举个例子，很多情况下，数据库中存在父子关系的数据保存在一张表里，而关联关系通过"parentId"属性进行关联，后端在数据查询时，会得到一个数组，此时前端可能需要将数据展示为树状结构，例如一个中后台的权限数据。 很多开发者采用的方式是一遍一遍的遍历数据，比如第一次遍历找到根节点，接着再遍历数据找到根节点的子节点，再遍历数据找到其个子节点的子节点，即使是把已经...
数据库中ID/ParentID模式的数据如何快速生成树形结构
wuda0112的专栏
05-27 1523
在数据库设计中，通常使用ID/PID这样的模式表示上下级关系，最常见的就是category表的设计，比如 CREATE TABLE IF NOT EXISTS `item`.`item_category` ( `item_category_id` BIGINT UNSIGNED NOT NULL, `store_id` BIGINT UNSIGNED NOT NULL COMMENT '所属店铺ID', `category_name` VARCHAR(45) NOT NULL COMMENT '
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值