【Java - List转Tree生成树状结构的数据】

最新推荐文章于 2024-04-24 09:14:49 发布
最新推荐文章于 2024-04-24 09:14:49 发布
阅读量962 收藏 11
点赞数 2
分类专栏： SpringBoot java 文章标签： java list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mrchai521/article/details/120369623
版权

需求场景

有下面一张菜单表，典型的树形结构设计

image.png
现前端需要后端返回树形数据结构用于构造展示树。

代码实战

  1. 首先我们根据数据库结构创建实体对象
@Data
@TableName("tb_menu")
public class Menu extends BaseEntity {
    private static final long serialVersionUID = 1L;

    /**
     * 菜单ID
     */
    @TableId
    private Long menuId;

    /**
     * 菜单名称
     */
    private String menuName;

    /**
     * 父菜单名称
     */
    @TableField(exist = false)
    private String parentName;

    /**
     * 父菜单ID
     */
    private Long parentId;

    /**
     * 显示顺序
     */
    private String orderNum;

    /**
     * 路由地址
     */
    private String path;

    /**
     * 组件路径
     */
    private String component;

    /**
     * 是否为外链（0是 1否）
     */
    private String isFrame;

    /**
     * 是否缓存（0缓存 1不缓存）
     */
    private String isCache;

    /**
     * 类型（M目录 C菜单 F按钮）
     */
    private String menuType;

    /**
     * 显示状态（0显示 1隐藏）
     */
    private String visible;

    /**
     * 菜单状态（0显示 1隐藏）
     */
    private String status;

    /**
     * 权限字符串
     */
    private String perms;

    /**
     * 菜单图标
     */
    private String icon;

    /**
     * 子菜单
     */
    @TableField(exist = false)
    private List<Menu> children = new ArrayList<Menu>();

最重要的还是id、parentId、children属性

最通用的写法（递归）

这种写法毫无节操可言，全部通过数据库递归查询。

  1. 首先查到根节点，parent_id = 0
  2. 通过根节点id获取到所有一级节点，parent_id = 1
  3. 递归获取所有节点的子节点，然后调用setChildren()方法组装数据结构。
    好多项目都是用这种方法。

1、递归：

/**
 * 根据父节点的id获取所有子节点
 *
 * @param menus
 * @return
 */
private List<Menu> getChildPerm(List<Menu> menus, int parentId) {
    List<Menu> menuList = new ArrayList<>();
    //当parentId = 0时，是根节点；
    // 获取根节点下的子节点
    for (Menu menu : menus) {
        if (menu.getParentId() == parentId) {
            Menu menuData = this.recursionTree(menus, menu);
            menuList.add(menuData);
        }

    }
    return menuList;
}
```
/**
 * 递归树结构
 *
 * @param collect
 */
private Menu recursionTree(List<Menu> collect, Menu menu) {
    List<Menu> childList = this.getChildList(collect, menu);
    menu.setChildren(childList);
    for (Menu col : childList) {
        if (hasChild(collect, col)) {
            recursionTree(collect, col);
        }
    }
    return menu;
}
**
 * 得到子节点列表
 */
private List<Menu> getChildList(List<Menu> list, Menu t) {
    List<Menu> tlist = new ArrayList<Menu>();
    Iterator<Menu> it = list.iterator();
    while (it.hasNext()) {
        Menu n = (Menu) it.next();
        if (n.getParentId().longValue() == t.getMenuId().longValue()) {
            tlist.add(n);
        }
    }
    return tlist;
}

这样比较啰嗦，性能不是很好，逻辑也不是很清楚。

2、双重循环：

这种写法比较简单，也是比较容易想到的。通过双重循环确定父子节点的关系。

/**
 * 获取菜单的树状结构
 *
 * @return
 */
private List<Menu> menuTrees() {
    List<Menu> list = new ArrayList<>();
    List<Menu> menus = menuMapper.selectList(null);
    for (Menu m : menus) {
        //获取根节点
        if (m.getParentId().equals(0L)) {
            list.add(m);
        }
        for (Menu child : menus) {
            if (child.getParentId().equals(m.getMenuId())) {
                m.addChild(child);
            }
        }
    }
    return list;
}
//菜单的实体类中加addChild方法
public void addChild(Menu menu) {
    if (children == null) {
        children = new ArrayList<>();
    }
    children.add(menu);
}

3、双重遍历

第一次遍历借助hashmap存储父节点与子节点的关系，第二次遍历设置子节点，由于map中已经维护好了对应关系所以只需要从map取即可。

/**
 * 双重查询
 *
 * @return
 */
private List<Menu> menuList() {
    Map<Long, List<Menu>> menuMap = new HashMap<>();
    List<Menu> menuList = menuMapper.selectList(null);
    menuList.forEach(menu -> {
        List<Menu> children = menuMap.getOrDefault(menu.getParentId(), new ArrayList<>());
        children.add(menu);
        menuMap.put(menu.getParentId(), children);
    });

    menuList.forEach(menu -> menu.setChildren(menuMap.get(menu.getMenuId())));

    List<Menu> result = menuList.stream().filter(v -> v.getParentId().equals("0")).collect(Collectors.toList());
    return result;
}

4、Stream分组


/**
 * Stream分组
 */
@Override
public List<Menu> selectMenuTree() {
    List<Menu> menus = menuMapper.selectList(null);
    //操作所有菜单数据
    Map<Long, List<Menu>> groupMap = menus.stream().collect(Collectors.groupingBy(Menu::getParentId));
    menus.forEach(menu -> {
        menu.setChildren(groupMap.get(menu.getMenuId()));
    });
    List<Menu> collect = menus.stream().filter(menu -> menu.getParentId().equals(0L)).collect(Collectors.toList());
    return collect;
}

此方法主要通过Collectors.groupingBy(Menu::getParentId)方法对menus按照parentId进行分组，分组后父节点相同的都放一起了。

然后再循环menus，给其设置children属性。

执行完成后已经形成了多颗树，最后我们再通过filter()方法挑选出根节点的那颗树即可。

请求后返回的数据集如下：

  "code": 200,
  "data": [
    {
      "searchValue": null,
      "createBy": "admin",
      "createTime": "2021-03-10 16:30:56",
      "updateBy": "",
      "updateTime": null,
      "remark": "系统管理目录",
      "params": null,
      "menuId": 1,
      "menuName": "系统管理",
      "parentName": null,
      "parentId": 0,
      "orderNum": "1",
      "path": "system",
      "component": null,
      "isFrame": "1",
      "isCache": "0",
      "menuType": "M",
      "visible": "0",
      "status": "0",
      "perms": "",
      "icon": "system",
      "children": [
        {
          "searchValue": null,
          "createBy": "admin",
          "createTime": "2021-03-10 16:30:56",
          "updateBy": "",
          "updateTime": null,
          "remark": "用户管理菜单",
          "params": null,
          "menuId": 100,
          "menuName": "用户管理",
          "parentName": null,
          "parentId": 1,
          "orderNum": "1",
          "path": "user",
          "component": "system/user/index",
          "isFrame": "1",
          "isCache": "0",
          "menuType": "C",
          "visible": "0",
          "status": "0",
          "perms": "system:user:list",
          "icon": "user",
          "children": [
            {
              "searchValue": null,
              "createBy": "admin",
              "createTime": "2021-03-10 16:31:00",
              "updateBy": "",
              "updateTime": null,
              "remark": "",
              "params": null,
              "menuId": 1001,
              "menuName": "用户查询",
              "parentName": null,
              "parentId": 100,
              "orderNum": "1",
              "path": "",
              "component": "",
              "isFrame": "1",
              "isCache": "0",
              "menuType": "F",
              "visible": "0",
              "status": "0",
              "perms": "system:user:query",
              "icon": "#",
              "children": null
            },
            {
              "searchValue": null,
              "createBy": "admin",
              "createTime": "2021-03-10 16:31:00",
              "updateBy": "",
              "updateTime": null,
              "remark": "",
              "params": null,
              "menuId": 1002,
              "menuName": "用户新增",
              "parentName": null,
              "parentId": 100,
              "orderNum": "2",
              "path": "",
              "component": "",
              "isFrame": "1",
              "isCache": "0",
              "menuType": "F",
              "visible": "0",
              "status": "0",
              "perms": "system:user:add",
              "icon": "#",
              "children": null
            },
            {
              "searchValue": null,
              "createBy": "admin",
              "createTime": "2021-03-10 16:31:01",
              "updateBy": "",
              "updateTime": null,
              "remark": "",
              "params": null,
              "menuId": 1003,
              "menuName": "用户修改",
              "parentName": null,
              "parentId": 100,
              "orderNum": "3",
              "path": "",
              "component": "",
              "isFrame": "1",
              "isCache": "0",
              "menuType": "F",
              "visible": "0",
              "status": "0",
              "perms": "system:user:edit",
              "icon": "#",
              "children": null
            }
          ]
        }
      ]
    }
  ]
}
Mrchai521
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中平铺列表（List）与树形（Tree）结构的互转
m0_48922996的博客
07-16 3218
至此，递归和非递归分别实现listtotree和treetolist已完成，实现比较仓促，有很多细节处未处理好，希望看到的小伙伴及时指出，不胜感激。另外，机智的你，有其它更好的方法，实现转换吗？欢迎留言分享，码海无涯，共同进步。httpshttps。...
【Java】多叉树全路径遍历/TireTree实现模糊查找
qq_46097430的博客
03-28 1165
import java.util.*; /** * ClassName: TireTree * Author:Daniel * Date 2022/3/26 * Version: 1.0 * Description: 字典查找树 */ public class TireTree { /** * 内部节点 */ static class Node{ private char data; /** * 字符降序排列
java list列表转tree树
最新发布
qq_24902851的博客
04-24 210
具有上下级关系的列表转化成树。
Java读取指定目录，返回树形结构数据
tanqingfu1的博客
04-25 2861
1、添加依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.3</version> </dependency> <dependencies> <dependency> <groupId>org.projectlombok<
Java父子结构转树形（路径）结构 demo
qq_38820154的博客
03-05 922
原数据结构 16385,[16395, 16386, 16387] 16395,[16410, 16412, 16415, 16399, 16398, 16397, 16411] 16389,[16394] 16400,[16401, 16426] 16411,[16421, 16418, 16422, 16419] 16433,[16439] 16388,[16389] 16399,[16435...
Morris算法遍历二叉树
qq_40585050的博客
09-09 580
中序遍历步骤 如果当前节点左子节点(cur.left)为空，输出当前节点(cur)，进入右子节点(cur.right)。 如果当前节点左子节点(cur.left)非空，找到当前节点左子树的最右节点(mostRight)： 1）如果该节点的右子节点(mostRight.right)为空，则将其指针指向当前节点(cur)，进入左子节点(cur.left)。 2）如果该节点的右子节点(mostRight.right)非空，则将其指针置为空，输出当前节点(cur)，进入右子节点(cur.right)。
Java 将有父子关系的数据转换成树形结构数据
01-07
一、数据库父子结构数据设计  大部分采用 parentId的形式来存储父id，并且只存储父id，祖父Id不存储。也可以添加存储层级级别或者层级关系等字段。 CREATE TABLE `t_resource` ( `id` varchar(255) NOT NULL ...
java版list-map实现 树结构 父子结构 通俗易懂
12-12
此java类实现了对数据表的分类递归树的实现，为本人倾力之作，后期，会发布js版，敬请期待！
Element的el-tree控件后台数据结构的生成以及方法的抽取
10-15
el-tree控件的后台数据结构生成和方法抽取是实现动态加载、异步数据加载以及树状数据操作的关键。 首先，让我们深入理解el-tree的数据结构。在Element UI中，el-tree控件需要的数据结构通常是一个包含多个对象的...
java根据数据库表内容生产树结构json数据的方法
10-20
本文将详细介绍如何使用Java根据数据库表内容生成树结构的JSON数据。 首先，我们来看一个具体的利用场景。假设我们有一个组织机构表，其中包含code（代码）、pcode（上级代码）和name（组织名称）等字段。这样的...
JSP无限级分类目录树-sorttree.zip
03-16
总之，“JSP无限级分类目录树_sorttree.zip”是一个关于Java Web开发的实践案例，涵盖了数据模型、数据库操作、JSP页面渲染等多个方面，对于学习和掌握动态生成无限级分类目录树的技能非常有帮助。通过这个项目，...
List和tree相互转换
01-19
java中List结构与tree结构相互转化。可实现list转树与tree转list。本链接为解读https://jingyan.baidu.com/article/455a99507b687da1662778ec.html。
Java List结构转Tree树形结构_非递归_简单优化版
qq_34466253的博客
10-24 2921
背景 之前写过一个文章Java递归将List数据转换为Tree结构数据_填坑指南用的是递归的方法，后来在今日头条上也发布了，评论区以为大佬给了我一些指点（如下图），我看了之后恍然大悟，相对于使用递归，此方法只需写一个方法，方法中两个循环，而使用递归的话，需要写三个方法，还要用递归，使用递归不仅内存开销大，性能也不行。 大佬提供的代码 具体实现 /** * 对象List转为Tree树形结构 * @param entityList 传进来的泛型List * ..
Java将List数据转换为树形结构
在下令狐的博客
12-16 1690
转换前数据结构： 转换后数据结构： 代码实现： import com.fasterxml.jackson.annotation.JsonInclude; import java.util.List; /** * @author 在下令狐 * @date 2021/12/16 */ public class Menu { private String menuCode; private String menuName; private String parentMe
java list 转树 tree
weixin_41905537的博客
09-19 373
在做目录树的时候通常是将一个目录存在数据库的List全部返回来，再根据节点id和parentId组装成一颗树。 List转成Tree有两种方式，一种是常用的递归，一种是双层循环。(建议递归) package com.gysoft.utils.tree; import lombok.Data; import lombok.ToString; import java.util.List...
java根据父类id生成Tree形数据（Stream流方式）
qq_44430410的博客
03-30 3293
java根据父类id为0生成Tree树形数据（Stream（）流方式）
java--list转树形结构
qq_43399762的博客
12-22 2162
【代码】java--list转树形结构。
java转换list成tree的数据结构
m0_46325101的博客
08-13 285
1、Java递归将List数据转换为Tree结构数据 https://blog.csdn.net/yuan_xiaohou/article/details/82461892?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2aggregatepagefirst_rank_v2~rank_aggregation-1-82461892.pc_agg_rank_aggregation&utm_term=Java+%E5%B0%86
java 根据路径自动生成树结构
weixin_37639280的博客
08-13 1974
import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.List; public class Demo { public static void main(String[] args){ List<String> data = Arrays.asList("/foo", "/bar", "/foo/admin", "/foo/...
java8 list转tree
04-07
Java8中可以使用Stream API和Collectors工具类将List转换成Tree。具体方法可以参考以下代码： ``` public static <T extends TreeNode> List<T> buildTree(List<T> list) { Map, T> map = list.stream().collect...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值