Java8 Stream流处理树形结构数据

这篇具有很好参考价值的文章主要介绍了Java8 Stream流处理树形结构数据。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

参考资料

  1. Java8新特性-使用Stream流递归实现遍历树形结构


一. 实体类

import lombok.Builder;
import lombok.Data;

import java.util.List;

@Data
@Builder
public class Menu {
	// 菜单id
    public Integer id;
	// 菜单名称
    public String name;
	// 菜单父级id
    public Integer parentId;
	// 菜单子级id列表
    public List<Menu> childList;

    public Menu(Integer id, String name, Integer parentId) {
        this.id = id;
        this.name = name;
        this.parentId = parentId;
    }

    public Menu(Integer id, String name, Integer parentId, List<Menu> childList) {
        this.id = id;
        this.name = name;
        this.parentId = parentId;
        this.childList = childList;
    }
}

二. 模拟查询树形结构数据

  • ID为2,6,11的Menu 是 ID为1的Menu子节点
  • ID为3,4,5的Menu 是 ID为2的Menu子节点
private List<Menu> queryDataFromDB() {
		
		// 模拟从数据库查询得到数据
        return Arrays.asList(

                new Menu(1, "根节点1", 0),
	
                new Menu(2, "子根节点1", 1),
                new Menu(3, "子节点1.1", 2),
                new Menu(4, "子节点1.2", 2),
                new Menu(5, "子节点1.3", 2),

                new Menu(6, "子根节点2", 1),
                new Menu(7, "子节点2.1", 6),
                new Menu(8, "子节点2.2", 6),
                new Menu(9, "子节点2.2.1", 8),
                new Menu(10, "子节点2.2.2", 8),

                new Menu(11, "子根节点3", 1),
                new Menu(12, "子节点3.1", 11),

                new Menu(13, "根节点2", 0),

                new Menu(14, "子根节点1", 13),
                new Menu(15, "子根节点2", 13)
        );
}

三. 使用stream流处理为树形结构

public void run(String... args) {

    List<Menu> menuList = this.queryDataFromDB();

    List<Menu> resultList = menuList.stream()
    		// 过滤出根节点
            .filter(menu -> menu.getParentId() == 0)
            .peek(menu -> menu.setChildList(this.getChildList(menu, menuList)))
            .collect(Collectors.toList());
	
	// 🧐最终得到树形结构数据
    System.out.println(resultList);
}

private List<Menu> getChildList(Menu rootMenu, List<Menu> menuList) {
    return menuList.stream()
    		// 过滤出ParentId和指定的id相等的数据
            .filter(menu -> Objects.equals(menu.getParentId(), rootMenu.getId()))
            // 递归调用
            .peek(menu -> menu.setChildList(this.getChildList(menu, menuList)))
            .collect(Collectors.toList());
}

💥注意

// ...
.peek(menu -> menu.setChildList(this.getChildList(menu, menuList)))
// ...

是下面这种写法的一种更简单的写法文章来源地址https://www.toymoban.com/news/detail-788985.html

// ...
.map(menu -> {
    menu.setChildList(this.getChildList(menu, menuList));
    return menu;
})
// ...

四. 处理完的树形结构数据

[
    {
        "id": 1,
        "name": "根节点1",
        "parentId": 0,
        "childList": [
            {
                "id": 2,
                "name": "子根节点1",
                "parentId": 1,
                "childList": [
                    {
                        "id": 3,
                        "name": "子节点1.1",
                        "parentId": 2,
                        "childList": []
                    },
                    {
                        "id": 4,
                        "name": "子节点1.2",
                        "parentId": 2,
                        "childList": []
                    },
                    {
                        "id": 5,
                        "name": "子节点1.3",
                        "parentId": 2,
                        "childList": []
                    }
                ]
            },
            {
                "id": 6,
                "name": "子根节点2",
                "parentId": 1,
                "childList": [
                    {
                        "id": 7,
                        "name": "子节点2.1",
                        "parentId": 6,
                        "childList": []
                    },
                    {
                        "id": 8,
                        "name": "子节点2.2",
                        "parentId": 6,
                        "childList": [
                            {
                                "id": 9,
                                "name": "子节点2.2.1",
                                "parentId": 8,
                                "childList": []
                            },
                            {
                                "id": 10,
                                "name": "子节点2.2.2",
                                "parentId": 8,
                                "childList": []
                            }
                        ]
                    }
                ]
            },
            {
                "id": 11,
                "name": "子根节点3",
                "parentId": 1,
                "childList": [
                    {
                        "id": 12,
                        "name": "子节点3.1",
                        "parentId": 11,
                        "childList": []
                    }
                ]
            }
        ]
    },
    {
        "id": 13,
        "name": "根节点2",
        "parentId": 0,
        "childList": [
            {
                "id": 14,
                "name": "子根节点1",
                "parentId": 13,
                "childList": []
            },
            {
                "id": 15,
                "name": "子根节点2",
                "parentId": 13,
                "childList": []
            }
        ]
    }
]

到了这里,关于Java8 Stream流处理树形结构数据的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java8中Stream详细用法大全

    Java 8 是一个非常成功的版本,这个版本新增的Stream,配合同版本出现的Lambda ,给我们操作集合(Collection)提供了极大的便利。Stream流是JDK8新增的成员,允许以声明性方式处理数据集合,可以把Stream流看作是遍历数据集合的一个高级迭代器。Stream 是 Java8 中处理集合的关键抽

    2023年04月08日
    浏览(69)
  • Java8 函数式编程stream流

    Java 8 中新增的特性旨在帮助程序员写出更好的代码,其中对核心类库的改进是很关键的一部分,也是本章的主要内容。对核心类库的改进主要包括集合类的 API 和新引入的流(Stream),流使程序员得以站在更高的抽象层次上对集合进行操作。下面将介绍stream流的用法。 ​场景

    2024年02月15日
    浏览(26)
  • Java8的Stream流的学习

    Stream可以由数组或集合创建,对流的操作分为两种: 中间操作,每次返回一个新的流,可以有多个。 终端操作,每个流只能进行一次终端操作,终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。 stream和parallelStream的简单区分: stream是顺序流,由主线程按

    2024年02月07日
    浏览(32)
  • Java8 Stream 之groupingBy 分组讲解

    本文主要讲解:Java 8 Stream之Collectors.groupingBy()分组示例 Collectors.groupingBy() 分组之常见用法 功能代码: /**      * 使用java8 stream groupingBy操作,按城市分组list      */     public void groupingByCity() {         MapString, ListEmployee map = employees.stream().collect(Collectors.groupingBy(Employee::getCi

    2024年02月13日
    浏览(36)
  • java8 Stream流常用方法(持续更新中...)

    操作对象 模拟数据 操作 打印结果 打印结果 注意:异常自己捕捉,就比如这里String转Intger就可能出现NumberFormatException异常 打印结果 打印结果 断点查看 打印结果 断点查看 持续更新中…

    2024年04月28日
    浏览(47)
  • Java8的stream之groupingBy()分组排序

    groupingBy()是Stream API中最强大的收集器Collector之一,提供与SQL的GROUP BY子句类似的功能。 需要指定一个属性才能使用,通过该属性执行分组。我们通过提供功能接口的实现来实现这一点 - 通常通过传递lambda表达式。 TreeMap默认按照key升序排序,collectPlan.descendingMap()可以进行降序排

    2024年02月12日
    浏览(32)
  • Java8 Stream流常见操作--持续更新中

    Java8 Stream流是一种处理数据集合的方式,它可以对集合进行一系列的操作,包括过滤、映射、排序等,从而实现对集合中元素的处理和转换。Stream流是一种惰性求值的方式,只有在需要返回结果时才会执行实际操作,这种方式可以提高程序的性能。 延迟执行:Stream流中的操作

    2024年02月11日
    浏览(49)
  • JAVA-- 在Java8 Parallel Stream中如何自定义线程池?

    使用Parallel Stream时,在适当的环境中,通过适当地使用并行度级别,可以在某些情况下获得性能提升。 如果程序创建一个自定义ThreadPool,必须记住调用它的shutdown()方法来避免内存泄漏。 如下代码示例,Parallel Stream并行处理使用的线程池是ForkJoinPool.commonPool(),这个线程池是

    2024年02月09日
    浏览(34)
  • Java8-使用stream.sorted()对List排序

    1.流的定义 Stream 中文称为 “流”,通过将集合转换为这么一种叫做 “流” 的元素序列,通过声明性方式,能够对集合中的每个元素进行一系列并行或串行的操作! 如果流中的元素的类实现了 Comparable 接口,即有自己的排序规则,那么可以直接调用 sorted() 方法对元素进行排

    2024年02月16日
    浏览(37)
  • JAVA8中list.stream()的一些简单使用

    为函数式编程而生。对stream的任何修改都不会修改背后的数据源,比如对stream执行过滤操作并不会删除被过滤的元素,而是会产生一个不包含被过滤元素的新stream。 stream上的操作并不会立即执行,只有等到用户真正需要结果的时候才会执行。 stream只能被使用一次,一旦遍历

    2024年02月03日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包