详解Java递归实现树形结构的两种方式
目录
- 0、引言
- 1、数据准备
- 2、类型转化
- 3、递归实现方法
- 3.1、Java7及以下纯Java递归实现
- 3.2、Java8及以上借助lamda表达式实现
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递归实现树形结构的两种方式的文章就介绍到这了,更多相关Java递归实现树形结构内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
使用递归删除树形结构的所有子节点(java和mysql实现)
1.业务场景 有如下树形结构: +-0 +-1 +-2 +-4 +-5 +-3 如果删除某个父节点,则其子节点,以及其子节点的子节点,以此类推,需要全部删除. 2.Java实现 使用Map存储树形结构的数据,id为map的key,pid为树形结构的value. import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.uti
-
使用Java将一个List运用递归转成树形结构案例
在开发中,我们会遇到将不同组织架构合并成tree这种树状结构,那么如果做呢? 实际上,我们也可以理解为如何将拥有父子关系的list转成树形结构,而这其中主要的方法就是递归! 1.实体对象: @Data public class Node { private Integer id; private String city; private Integer pid; private List<Node> children; public Node(Integer id,String city,In
-
Java 递归查询部门树形结构数据的实践
说明:在开发中,我们经常使用树形结构来展示菜单选项,如图: 那么我们在后端怎么去实现这样的一个功能呢? 1.数据库表:department 2.编写sql映射语句 <select id="selectDepartmentTrees" resultType="com.welb.entity.Department"> select * from department <where> <if test="updepartmentco
-
java、js中实现无限层级的树形结构方法(类似递归)
js中: var zNodes=[ {id:0,pId:-1,name:"Aaaa"}, {id:1,pId:0,name:"A"}, {id:11,pId:1,name:"A1"}, {id:12,pId:1,name:"A2"}, {id:13,pId:1,name:"A3"}, {id:2,pId:0,name:"B"}, {id:21,pId:2,name:"B1&qu
-
Java递归遍历树形结构
废话不多说了,直接给大家贴代码,具体代码如下所示: //菜单树形结构 public JSONArray treeMenuList(JSONArray menuList, int parentId) { JSONArray childMenu = new JSONArray(); for (Object object : menuList) { JSONObject jsonMenu = JSONObject.fromObject(object); int menuId = jsonMenu.ge
-
详解Java递归实现树形结构的两种方式
目录 0.引言 1.数据准备 2.类型转化 3.递归实现方法 3.1.Java7及以下纯Java递归实现 3.2.Java8及以上借助lamda表达式实现 0.引言 在开发的过程中,很多业务场景需要一个树形结构的结果集进行前端展示,也可以理解为是一个无限父子结构,常见的有报表指标结构.菜单结构等.Java中递归实现树形结构的两种常见方式如下: Java7及以下纯Java递归实现 Java8及以上借助lamda表达式实现 1.数据准备 Java实体类NodePO对应数据库表 package com
-
详解Java中数组判断元素存在几种方式比较
1. 通过将数组转换成List,然后使用List中的contains进行判断其是否存在 public static boolean useList(String[] arr,String containValue){ return Arrays.asList(arr).contains(containValue); } 需要注意的是Arrays.asList这个方法中转换的List并不是java.util.ArrayList而是java.util.Arrays.ArrayList,其中java.
-
详解Python修复遥感影像条带的两种方式
GDAL修复Landsat ETM+影像条带 Landsat7 ETM+卫星影像由于卫星传感器故障,导致此后获取的影像出现了条带.如下图所示, 影像中均匀的布满条带. 使用GDAL修复影像条带的代码如下: def gdal_repair(tif_name, out_name, bands): """ tif_name(string): 源影像名 out_name(string): 输出影像名 bands(integer): 影像波段数 """ #
-
详解python连接telnet和ssh的两种方式
目录 Telnet 连接方式 ssh连接方式 Telnet 连接方式 #!/usr/bin/env python # coding=utf-8 import time import telnetlib import logging __author__ = 'Evan' save_log_path = 'result.txt' file_mode = 'a+' format_info = '%(asctime)s - %(filename)s[line:%(lineno)d] - %(level
-
详解pytorch的多GPU训练的两种方式
目录 方法一:torch.nn.DataParallel 1. 原理 2. 常用的配套代码如下 3. 优缺点 方法二:torch.distributed 1. 代码说明 方法一:torch.nn.DataParallel 1. 原理 如下图所示:小朋友一个人做4份作业,假设1份需要60min,共需要240min. 这里的作业就是pytorch中要处理的data. 与此同时,他也可以先花3min把作业分配给3个同伙,大家一起60min做完.最后他再花3min把作业收起来,一共需要66min. 这个
-
详解JavaScript发送埋点请求的两种方式
目录 一.用法 1.动态创建<img> 2.动态创建<script> 二.区别 区别1 区别2 三.选择哪种方式 四.总结 对于统计页面数据这样的情景(俗称埋点),我们常用的方式就是动态创建<img>或<script>,至于原因,一般有以下几点: 1.埋点一般不用关心请求的结果 2.可以实现跨域请求 3.无需使用ajax就能达到发请求的目的 4.都是原生实现,兼容性好 现就两种方式做一下对比和总结: 一.用法 1.动态创建<img> 方式1:通过
-
详解Spring Boot 中实现定时任务的两种方式
在 Spring + SpringMVC 环境中,一般来说,要实现定时任务,我们有两中方案,一种是使用 Spring 自带的定时任务处理器 @Scheduled 注解,另一种就是使用第三方框架 Quartz ,Spring Boot 源自 Spring+SpringMVC ,因此天然具备这两个 Spring 中的定时任务实现策略,当然也支持 Quartz,本文我们就来看下 Spring Boot 中两种定时任务的实现方式. @Scheduled 使用 @Scheduled 非常容易,直接创建一个
-
详解android与服务端交互的两种方式
做Android开发的程序员必须知道android客户端应该如何与服务端进行交互,这里主要介绍的是使用json数据进行交互.服务端从数据库查出数据并以json字符串的格式或者map集合的格式返回到客户端,客户端进行解析并输出到手机屏幕上. 此处介绍两种方式:使用Google原生的Gson解析json数据,使用JSONObject解析json数据 一.使用Google原生的Gson解析json数据: 记得在客户端添加gson.jar. 核心代码: 服务端: package com.mfc.ctrl
-
详解Springboot之接收json字符串的两种方式
第一种方式.通过关键字段@RequestBody,标明这个对象接收json字符串.还有第二种方式,直接通过request来获取流.在spring中,推荐使用. 代码地址 https://gitee.com/yellowcong/springboot-demo/tree/master/springboot-json 项目结构 其实项目里面没啥类容,就是一个控制器和pom.xml配置 配置fastjson 添加fastjson的依赖到pom.xml中 <dependency> <groupI
-
详解IntelliJ IDEA创建spark项目的两种方式
Intellij是进行scala开发的一个非常好用的工具,可以非常轻松查看scala源码,当然用它来开发Java也是很爽的,之前一直在用scala ide和eclipse,现在换成intellij简直好用到飞起,但是有些人不知道怎么用intellij去创建一个spark项目,这里介绍两种 1.选择File->new Project->Java->Scala,这里scala版本是2.11.8 2 .之后一路点击next,直到finish,创建完的项目见下图,这时候已经可以创建scala文件