Java递归实现树形结构的两种方式

最新推荐文章于 2024-06-13 11:20:13 发布
最新推荐文章于 2024-06-13 11:20:13 发布
阅读量1.1w 收藏 61
点赞数 11
分类专栏： Java编程技术 文章标签： java 递归 BeanMap lamda表达式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52596258/article/details/127471217
版权

目录

0、引言

在开发的过程中，很多业务场景需要一个树形结构的结果集进行前端展示，也可以理解为是一个无限父子结构，常见的有报表指标结构、菜单结构等。Java中递归实现树形结构的两种常见方式如下：

  • Java7及以下纯Java递归实现
  • Java8及以上借助lamda表达式实现

1、数据准备

Java实体类NodePO对应数据库表

package com.wbs.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@NoArgsConstructor
public class NodePO {

    /**
     * 当前节点id
     */
    private String id;

    /**
     * 当前节点名称
     */
    private String name;

    /**
     * 父级节点id
     */
    private String parentId;

    /**
     * 当前节点序号
     */
    private String orderNo;

    /**
     * 子集节点
     */
    private List<NodePO> children;

    /**
     * 构造函数
     * @param id
     * @param name
     * @param parentId
     * @param orderNo
     */
    public NodePO(String id,String name,String parentId,String orderNo){
        this.id = id;
        this.name = name;
        this.parentId = parentId;
        this.orderNo = orderNo;
    }
}

​ 自己造一些数据模拟从数据库中查询出来的数据：

static final List<NodePO> nodePOs = Arrays.asList(
            new NodePO("1","一级节点1",null,"_0001"),
            new NodePO("2","二级节点1.1","1","_0002"),
            new NodePO("3","二级节点1.2","1","_0003"),

            new NodePO("4","一级节点2",null,"_0004"),
            new NodePO("5","二级节点2.1","4","_0005"),
            new NodePO("6","二级节点2.2","4","_0006"),
            new NodePO("7","三级节点2.2.1","6","_0007"),

            new NodePO("8","一级节点3",null,"_0008"),
            new NodePO("9","二级节点3.1","8","_0009"),
            new NodePO("10","三级节点3.1.1","9","_0010"),
            new NodePO("11","四级节点3.1.1.1","10","_0011"),
            new NodePO("12","五级节点3.1.1.1.1","11","_0012")
    );

2、类型转化

从开发的过程中发现直接操作实体类集合，专门指定某一个实体类封装的方法是不具有普适性的，所以将实体类集合统一转化为Map集合，操作方便，具有一定的普适性：

List<Map<String, Object>> mapList = BeanMapUtils.listBeanToListMap(jsonObject);

BeanMapUtils自己简单封装一个工具类（不惧普适性勿喷）：

package com.wbs.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import lombok.SneakyThrows;
import org.springframework.cglib.beans.BeanMap;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author 一宿君
 * @version Id: BeanMapUtils.java, v 0.1 Administrator Exp $$
 * @date 2022-10-13 14:24:20
 * @desc java实体类和map相互转换工具类
 */
public class BeanMapUtils {

    /**
     * 将实体类对象属性转化为map对象
     * @param t
     * @param <T>
     * @return
     */
    public static <T> Map<String, Object> beanToMap(T t) {
        Map<String, Object> map = new HashMap<>();
        if (t != null) {
            if (t instanceof JSONObject){
                return (JSONObject)t;
            }
            BeanMap beanMap = BeanMap.create(t);
            for (Object key : beanMap.keySet()) {
                map.put(key.toString(), beanMap.get(key));
            }
        }
        return map;
    }


    /**
     * 将map对象中转化为实体类对象
     * @param map
     * @param clazz
     * @param <T>
     * @return
     * @throws Exception
     */
    public static <T> T mapToBean(Map<String, Object> map,Class<T> clazz) throws Exception {
        T bean = clazz.newInstance();
        if (bean instanceof JSONObject){
            JSONObject jsonObject = (JSONObject)bean;
            Set<Map.Entry<String, Object>> entries = map.entrySet();
            for (Map.Entry<String, Object> entry : entries) {
                jsonObject.put(entry.getKey(),entry.getValue());
            }
            return (T)jsonObject;
        }
        BeanMap beanMap = BeanMap.create(bean);
        beanMap.putAll(map);
        return bean;
    }

    /**
     * 通过lambda表达式将List<JavaBean>转化为List<Map<String, Object>>
     * @param objList
     * @param <T>
     * @return
     */
    public static <T> List<Map<String, Object>> listBeanToListMap(List<T> objList) {
        return objList.stream().map(new Function<T, Map<String, Object>>() {
            @Override
            public Map<String, Object> apply(T t) {
                Map<String,Object> map = Maps.newHashMap();
                if (t instanceof JSONObject){
                    return (JSONObject)t;
                }
                BeanMap beanMap = BeanMap.create(t);
                for (Object key : beanMap.keySet()) {
                    map.put(key.toString(), beanMap.get(key));
                }
                return map;
            }
        }).collect(Collectors.toList());
    }

    /**
     * 通过lambda表达式将List<Map<String, Object>>转化为List<JavaBean>
     * @param mapList
     * @param <T>
     * @return
     */
    public static <T> List<T> listMapToListBean(List<Map<String,Object>> mapList,Class<T> clazz) {
        return mapList.stream().map(new Function<Map<String, Object>,T>() {
            @SneakyThrows
            @Override
            public T apply(Map<String, Object> map) {
                T t = clazz.newInstance();
                if (t instanceof JSONObject){
                    return (T)map;
                }
                BeanMap beanMap = BeanMap.create(t);
                beanMap.putAll(map);
                return t;
            }
        }).collect(Collectors.toList());
    }
}

其中org.springframework.cglib.beans.BeanMap;是org.springframework:spring-core依赖下的工具包，spring-core核心依赖只要导入spring-boot-starter依赖即可

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.2.0.RELEASE</version>
</dependency>

在这里插入图片描述

3、递归实现方法

3.1、Java7及以下纯Java递归实现

既然是Java7及以下实现方式，那排序也用最原始的冒泡排序：

/**
     * 冒泡排序,小的在前，大的在后
     * @param list
     * @return
     */
    public static List<Map<String, Object>> sortJava7Map(List<Map<String, Object>> list){
        if(CollectionUtils.isEmpty(list)){
            return Lists.newArrayList();
        }
        boolean flag;
        int size = list.size();
        for (int i = 0; i < size - 1; i++) {
            flag = false;
            for (int j = 1; j < size - i; j++) {
                Map<String, Object> frontMap = list.get(j - 1);
                Map<String, Object> afterMap = list.get(j);
                if (String.valueOf(frontMap.get("orderNo")).compareTo(String.valueOf(afterMap.get("orderNo"))) > 0){
                    list.set(j - 1,afterMap);
                    list.set(j,frontMap);
                    flag = true;
                }
            }
            //如果没有发生位置互换，则退出循环
            if (!flag){
                break;
            }
        }
        return list;
    }

给定一个节点，获取它的所有子节点：

/**
     * Java7及以下版本获取子节点的方式
     * @param parentNode
     * @param allList
     * @return
     */
    public static List<Map<String, Object>> getJava7Children(Map<String,Object> parentNode,List<Map<String, Object>> allList){

        //存放当前节点的直系子节点
        List<Map<String, Object>> curNodeChildrenList = Lists.newArrayList();

        //存放直系子节点以外的节点
        List<Map<String, Object>> otherNodeList = Lists.newArrayList();

        Object pId = parentNode.get("id");
        for (Map<String, Object> map : allList) {
            Object curPId = map.get("parentId");
            if (ObjectUtils.isNotEmpty(curPId) && Objects.equals(pId,curPId)){
                curNodeChildrenList.add(map);
            }else {
                otherNodeList.add(map);
            }
        }
        if (curNodeChildrenList.isEmpty()){
            return curNodeChildrenList;
        }
        //每一层级都进行排序
        curNodeChildrenList = sortJava7Map(curNodeChildrenList);

        //迭代直系子节点再获取子节点
        for (Map<String, Object> map : curNodeChildrenList) {
            map.put("children",getJava7Children(map,otherNodeList));
        }
        return curNodeChildrenList;
    }

给出一个结果集，构建树形结果集：

/**
     * 使用Java7的方式获取树形结构
     * @param allList
     * @return
     */
    public static List<Map<String, Object>> getJava7ResultTree(List<Map<String, Object>> allList){
        //存放所有的一级节点
        List<Map<String, Object>> oneLevelNodeList = Lists.newArrayList();

        for (Map<String, Object> map : allList) {
            if (ObjectUtils.isEmpty(map.get("parentId"))){
                map.put("children",getJava7Children(map,allList));
                oneLevelNodeList.add(map);
            }
        }
        return sortJava8Map(oneLevelNodeList);
    }

获取树形结构：

//转化为Map集合
List<Map<String, Object>> mapList = BeanMapUtils.listBeanToListMap(nodePOs);
//获取树形结构
List<Map<String, Object>> java7ResultTree = getJava7ResultTree(mapList);
//打印输出
System.out.println(JSON.toJSONString(java7ResultTree));

打印结果：

[{"orderNo":"_0001","children":[{"orderNo":"_0002","children":[],"name":"二级节点1.1","id":"2","parentId":"1"},{"orderNo":"_0003","children":[],"name":"二级节点1.2","id":"3","parentId":"1"}],"name":"一级节点1","id":"1"},{"orderNo":"_0004","children":[{"orderNo":"_0005","children":[],"name":"二级节点2.1","id":"5","parentId":"4"},{"orderNo":"_0006","children":[{"orderNo":"_0007","children":[],"name":"三级节点2.2.1","id":"7","parentId":"6"}],"name":"二级节点2.2","id":"6","parentId":"4"}],"name":"一级节点2","id":"4"},{"orderNo":"_0008","children":[{"orderNo":"_0009","children":[{"orderNo":"_0010","children":[{"orderNo":"_0011","children":[{"orderNo":"_0012","children":[],"name":"五级节点3.1.1.1.1","id":"12","parentId":"11"}],"name":"四级节点3.1.1.1","id":"11","parentId":"10"}],"name":"三级节点3.1.1","id":"10","parentId":"9"}],"name":"二级节点3.1","id":"9","parentId":"8"}],"name":"一级节点3","id":"8"}]

树形结构搞定！

3.2、Java8及以上借助lamda表达式实现

Java7的方式虽然实现了树形结构，但是有一定的缺点，比如：代码量比较大，逻辑相对较复杂，那Java8是如何简化，如下所示：

既然Java8有lamda表达式，那代码我们能省就省，先看排序，一行代码搞定：

/**
     * 根据orderNo排序树形结构的每一个层级
     * @param list
     * @return
     */
    public static List<Map<String, Object>> sortJava8Map(List<Map<String, Object>> list){
        if(CollectionUtils.isEmpty(list)){
            return Lists.newArrayList();
        }
        //关键之处，一行代码搞定
        list.sort(Comparator.comparing(m -> String.valueOf(m.get("orderNo"))));
        return list;
    }

给定一个节点，获取它的所有子节点：

释义：
filter： 过滤，相当于for循环，再if条件判断。
peek： 给定一个节点，往它的children塞子节点。

/**
     * 根据父级节点获取所有的子集节点
     * @param parentNode
     * @param allList
     * @return
     */
    public static List<Map<String, Object>> getJava8Children(Map<String,Object> parentNode, List<Map<String, Object>> allList){
        return allList.stream()
                .filter(curNode -> ObjectUtils.isNotEmpty(curNode.get("parentId")) && Objects.equals(curNode.get("parentId"),parentNode.get("id")))
                .peek(m -> m.put("children", getJava8Children(m,allList))).collect(Collectors.toList());
    }

给出一个结果集，构建树形结果集：

/**
     * 获取树形结构
     * @param mapList
     * @return treeList 树形结果集
     */
    public static List<Map<String, Object>> getJava8ResultTree(List<Map<String, Object>> mapList){
        if (CollectionUtils.isEmpty(mapList)){
            return Lists.newArrayList();
        }
        //filter过滤出所有的一级节点
        return mapList.stream().filter(m -> Objects.equals(m.get("parentId"), null) || Objects.equals(m.get("parentId"), ""))
                .peek(m -> m.put("children", sortJava8Map(getJava8Children(m, mapList)))).collect(Collectors.toList());
    }

获取树形结构：

//转化为Map集合
List<Map<String, Object>> mapList = BeanMapUtils.listBeanToListMap(nodePOs);
//获取树形结构
List<Map<String, Object>> java8ResultTree = getJava8ResultTree(mapList);
//打印输出
System.out.println(JSON.toJSONString(java8ResultTree));

打印结果：

[{"orderNo":"_0001","children":[{"orderNo":"_0002","children":[],"name":"二级节点1.1","id":"2","parentId":"1"},{"orderNo":"_0003","children":[],"name":"二级节点1.2","id":"3","parentId":"1"}],"name":"一级节点1","id":"1"},{"orderNo":"_0004","children":[{"orderNo":"_0005","children":[],"name":"二级节点2.1","id":"5","parentId":"4"},{"orderNo":"_0006","children":[{"orderNo":"_0007","children":[],"name":"三级节点2.2.1","id":"7","parentId":"6"}],"name":"二级节点2.2","id":"6","parentId":"4"}],"name":"一级节点2","id":"4"},{"orderNo":"_0008","children":[{"orderNo":"_0009","children":[{"orderNo":"_0010","children":[{"orderNo":"_0011","children":[{"orderNo":"_0012","children":[],"name":"五级节点3.1.1.1.1","id":"12","parentId":"11"}],"name":"四级节点3.1.1.1","id":"11","parentId":"10"}],"name":"三级节点3.1.1","id":"10","parentId":"9"}],"name":"二级节点3.1","id":"9","parentId":"8"}],"name":"一级节点3","id":"8"}]

树形结构搞定！两种实现方式对比一下，你就说Java8的方式哇塞不哇塞！！！

在这里插入图片描述

一起学编程，让生活更随和！如果你觉得是个同道中人，欢迎关注博主公众号：【随和的皮蛋桑】。专注于Java基础、进阶、面试以及计算机基础知识分享🐳。偶尔认知思考、日常水文🐌。

在这里插入图片描述

一宿君
关注
  • 11
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Java树形结构 递归
z1696637434的博客
09-24 526
【代码】Java树形结构 递归。
java树结构、递归数据
不知道的博客
11-17 1687
我们在日常开发时经常会遇到需要给前端返回树结构数据，并且有的数据是无限极的，这个时候我们就需要递归算法。（英语：recursion algorithm）在中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。递归式方法可以被用于解决很多的计算机科学问题，因此它是计算机科学中十分重要的一个概念。绝大多数支持的自调用，在这些语言中函数可以通过调用自身来进行递归。可以证明递归的作用可以完全取代，因此在很多（如）中习惯用递归来实现循环。就是方法自己调用自己。
Java——递归
最新发布
Stewie Lee的博客
06-13 1452
回溯算法是一种系统化地搜索问题解空间的方法，主要用于解决组合优化问题。它通过递归地构建候选解，并在发现候选解不满足问题条件时回溯，从而尝试其他可能的选择。回溯算法的核心思想是不断尝试和撤销选择，直到找到所有可能的解决方案或者确认无解。
递归获取树形结构数据
hcg012的博客
07-29 2124
/** * 获取树形表结构数据 * @param list 表数据 * @param parentId 父节点id * @return 树形数据 */ @ServiceLog("获取树形表结构数据") public List<Map<Object, Object>> getOrgTree(List<Ma...
用递归算法得到Java的树形结构
山鬼谣的专栏
07-08 1万+
要求：得到无限分类的菜单栏。并且告诉你任何一个节点，都能得到整个菜单。数据库是mongodb。没有贴全部，只贴部分。 首先一个整体思路是： 1、要有一个能通过父类id得到全部子类id的集合。 2、遍历这些子类集合来把它们的关系关联起来。代码部分： 建立数据库的查询：DBCollection collection = GGMongoOperator.getGGBusinessCollectio
Java递归遍历树形结构
09-02
主要介绍了Java递归遍历树形结构的相关资料,需要的朋友可以参考下
递归循环获得tree树形结构数据
weixin_40045529的博客
03-30 2845
VUE + ElementUI tree组件树形数据处理 一、tree组件代码 <el-tree class="tree_s" :data="treeData" highlight-current :expand-on-click-node="false" node-key="id" default-expand-all :props="defaultProps...
jpa单表递归树形结构实现
07-23
总结，Spring JPA提供了一种优雅的方式处理单表递归树形结构。通过定义自关联的实体类、配置JPA仓库以及编写适当的查询方法，可以轻松地实现对树形数据的CRUD操作。在实际应用中，还需考虑性能优化，如分页加载、懒...
Java递归如何正确输出树形菜单
08-31
这样，我们通过递归实现了树形结构的遍历和输出。 最后，我们创建一个测试类`Test`，生成一些示例数据并调用`Tree`类的方法来构建和打印树形菜单： ```java public class Test { public static void main(String...
java编程两种树形菜单结构的转换代码
08-28
// 实现细节：遍历singleTreeNodes，根据pId构建树形结构并添加到multiTreeNodes } } ``` `ToMultiTreeTransformer`类接收一个`SingleTreeNode`列表，然后通过调用`transform()`方法将其转换为`MultiTreeNode`列表...
Java数据封装树形结构代码实例
08-25
本文详细介绍了Java数据封装树形结构代码实例的实现过程，涵盖了实体类的定义、数据封装、树形结构的构建、递归算法、Comparable接口、List接口、Date类和StringUtils类等多个知识点，对大家的学习或者工作具有一定...
java树结构递归里面详细说明
04-26
java后台常用的树结构，通过递归写成的。里面详细介绍了。树结构的用法实例。以及参考说明等。
用Java集合递归实现通用树Tree
11-28
不要分，要的是人气！资源很给力的！欢迎下载！
java递归树结构.rar
06-23
java 生成树结构的数据格式返回给前端。。这是demo最后生成的数据格式：[{"id":1,"name":"名字1","parentId":0,"children":[{"id":3,"name":"名字3","parentId":1,"children":[{"id":7,"name":"名字7","parentId":3,"children":[]},{"id":8,"name":"名字8","parentId":3,"children":[]}]},{"id":4,"name":"名字4","parentId":1,"children":[]}]},{"id":2,"name":"名字2","parentId":0,"children":[{"id":5,"name":"名字5","parentId":2,"children":[]},{"id":6,"name":"名字6","parentId":2,"children":[]}]}]，有需要的小伙伴可以下载看看
java递归树型结构通用数据库
01-25
java递归树型结构通用数据库
java树形结构递归实现
qq_44713813的博客
07-19 173
【代码】java树形结构代码实现。
递归生成树形结构
热门推荐
代码风的博客
06-22 2万+
TreeNode实体类 key-菜单id title-菜单名称 parentId-父子菜单id cildren-子菜单 import java.util.List; /** * @Author forewei * @date 2018-6-13 17:04 */ public class TreeNode { private Integer key; ...
MySQL 递归查找树形结构，这个方法太实用了！
Java笔记虾
06-21 9113
点击关注公众号，利用碎片时间学习这两天，遇到了子节点的需求。这里简单做个总结。1、数据库中的树形结构数据库中存贮的数据，以ID和P_ID(父id)，来存贮树形结构这样如果需要查找某个节点的子节点，就可以寻找P_ID。如果要查找所有子节点，就需要遍历所有的子节点的子节点。如果要判断是否为同级的节点，就可以查找是否有相同的父节点。2、MySQL中如何查找相应的数据这里，我采用...
java递归查询树形数据
weixin_42600128的博客
02-14 1147
递归是一种常见的树形数据查询方法，它在每次递归时都会将问题规模减小，直到问题的规模达到某个基准条件为止。 在 Java 中，递归查询树形数据的基本步骤如下： 定义一个递归函数，该函数接收当前节点作为参数。 判断当前节点是否是叶子节点，如果是，则返回。 否则，对于当前节点的每个子节点，递归调用该递归函数。 在递归函数中执行需要的操作，比如查询、修改或统计信息。 例如，下面是一个查询树形数...
java递归查询树形结构
05-12
实现树形结构的递归查询可以采用深度优先遍历算法（DFS）。具体实现可以按照以下步骤进行： 1. 定义树节点类，包括节点ID、父节点ID、节点名称等属性。 2. 定义树形结构类，包括根节点、节点列表等属性。节点列表可以使用Map集合来存储节点对象，以节点ID作为键。 3. 实现深度优先遍历算法，递归遍历树形结构。具体实现方式可以按照以下步骤进行： a. 从根节点开始遍历，将节点加入遍历路径中。 b. 遍历当前节点的所有子节点，如果子节点在遍历路径中已存在，则说明存在环路，返回空；否则，递归遍历子节点。 c. 如果子节点遍历完成后，没有找到目标节点，则将当前节点从遍历路径中移除，回溯到上一级节点继续遍历。 4. 调用深度优先遍历算法，查询目标节点。 下面是一个简单的Java代码示例： ```java public class TreeNode { private String id; private String parentId; private String name; // getter和setter方法省略 } public class Tree { private Map<String, TreeNode> nodeMap = new HashMap<String, TreeNode>(); private TreeNode root; // 添加节点方法 public void addNode(TreeNode node) { if (node == null) { return; } if (node.getParentId() == null || node.getParentId().equals("")) { this.root = node; } nodeMap.put(node.getId(), node); } // 根据节点ID查询节点 public TreeNode findNodeById(String id) { TreeNode node = nodeMap.get(id); if (node == null) { return null; } List<TreeNode> path = new ArrayList<TreeNode>(); if (dfs(node, path)) { return node; } else { return null; } } // 深度优先遍历算法 private boolean dfs(TreeNode node, List<TreeNode> path) { path.add(node); if (node.getId().equals(id)) { return true; } for (Map.Entry<String, TreeNode> entry : nodeMap.entrySet()) { TreeNode child = entry.getValue(); if (child.getParentId() == null || child.getParentId().equals("")) { continue; } if (child.getParentId().equals(node.getId())) { if (path.contains(child)) { // 存在环路，返回空 return false; } if (dfs(child, path)) { return true; } } } path.remove(node); return false; } } ``` 其中，addNode方法用于添加节点，findNodeById方法用于根据节点ID查询节点，dfs方法是深度优先遍历算法的实现。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一宿君

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值