Java 8 中的 Stream 轻松遍历树形结构

在平时的需求开发中，我们经常会遍历一些树形结构，数据库中使用父id来关联，为了降低数据库的查询压力，我们可以使用java8中的Stream流一次性把数据查出来，然后通过流式处理。
实体类：Menu.java

package com.example.tree;

import java.util.List;

/**
 * 菜单实体类
 * @date: 2023/12/28
 **/
public class Menu {
    private Integer id;
    private String name;
    private Integer parentId;
    private 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;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Integer getParentId() {
        return parentId;
    }

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

    public List<Menu> getChildList() {
        return childList;
    }

    public void setChildList(List<Menu> childList) {
        this.childList = childList;
    }
}

模拟查看数据库所有数据到List里面
测试类：testTree.java

package com.example.tree;

import com.alibaba.fastjson.JSON;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 测试树
 * @date: 2023/12/28
 **/
public class testTree {

    public static void main(String[] args) {
        List<Menu> menuList = Arrays.asList(
                new Menu(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",7),
                new Menu(10,"根节点2.2.2",7),
                new Menu(11,"根节点3",1),
                new Menu(12,"根节点3.1",11)
        );
        //获取父节点
        List<Menu> collect = menuList.stream().filter(m -> m.getParentId() == 0).map((m) -> {
            m.setChildList(getChildrens(m,menuList));
            return m;
        }).collect(Collectors.toList());
        System.out.println("============转json输出结果：");
        System.out.println(JSON.toJSON(collect));
    }

    /**
     * 递归查询子节点
     * @param root 根节点
     * @param all 所有节点
     * @return 根节点信息
     * @date 2023/12/28
     */
    private static List<Menu> getChildrens(Menu root, List<Menu> all) {
        List<Menu> children = all.stream().filter(m -> {
            return Objects.equals(m.getParentId(),root.getId());
        }).map(
                (m) -> {
                    m.setChildList(getChildrens(m,all));
                    return m;
                }
            ).collect(Collectors.toList());
        return children;
    }
}

打印结果：

[
    {
        "name":"根节点",
        "childList":[
            {
                "name":"子节点1",
                "childList":[
                    {
                        "name":"子节点1.1",
                        "childList":[

                        ],
                        "id":3,
                        "parentId":2
                    },
                    {
                        "name":"子节点1.2",
                        "childList":[

                        ],
                        "id":4,
                        "parentId":2
                    },
                    {
                        "name":"根节点1.3",
                        "childList":[

                        ],
                        "id":5,
                        "parentId":2
                    }
                ],
                "id":2,
                "parentId":1
            },
            {
                "name":"根节点2",
                "childList":[
                    {
                        "name":"根节点2.1",
                        "childList":[
                            {
                                "name":"根节点2.2.1",
                                "childList":[

                                ],
                                "id":9,
                                "parentId":7
                            },
                            {
                                "name":"根节点2.2.2",
                                "childList":[

                                ],
                                "id":10,
                                "parentId":7
                            }
                        ],
                        "id":7,
                        "parentId":6
                    },
                    {
                        "name":"根节点2.2",
                        "childList":[

                        ],
                        "id":8,
                        "parentId":6
                    }
                ],
                "id":6,
                "parentId":1
            },
            {
                "name":"根节点3",
                "childList":[
                    {
                        "name":"根节点3.1",
                        "childList":[

                        ],
                        "id":12,
                        "parentId":11
                    }
                ],
                "id":11,
                "parentId":1
            }
        ],
        "id":1,
        "parentId":0
    }
]