将两张表的数据封装成树，返回给前端

目前有部门表和用户表，部门表中有部门id，和父部门id等字段。用户表中有部门id（用户属于最子级部门）。如何将两张表（部门和用户表）的数据，封装在一起，可以列出部门下子部门，子部门下有用户的形式呢？
刚入门的Java小菜，求指教，谢谢各位！

创建两个实体类
先创建二级实体类，再创建一级实体类包含一级实体类

//一级分类
@Data
public class OneSubject {
    private String id;
    private String title;

    //一个一级分类有多个二级分类
    private List<TwoSubject> children = new ArrayList<>();
}

//二级分类
@Data
public class TwoSubject {
    private String id;
    private String title;
}

这方面的项目我有做过，你可以在实体类中加入一个List<...>集合，这个List用来存放子树，然后在实现类中遍历两边即可实现树形结构！希望能帮助到你

{
"id": 5,
"parentId": 1,
"userlist": [
{
"depId": 1,
"userName": "李四"
},
{
"depId": 1,
"userName": "陈陈"
}
]
}

id 部门Id
parentId 父部门Id
userlist 用户表数据
depId 部门Id
userName 用户名

按你说的大概想的是这样，再扩展一下应该可以得到你想要的
一般来说只加载最外层数据，然后通过页面点击展开再逐层加载子部门数据，不要一下子全捞出来

可以先把所有数据查出来 之后 按照 父id 分组 放到 map里 之后 遍历所有部门 生成树

正好我写了一个

public class Node {
    List<User> users;
    List<Dept> depts;
    List<Node> children;
}

推荐数组转树形工具类

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;

public class ArraysToTreeUtil<T> {
    private Function<T, Object> parent;
    private Function<T, Object> code;
    private Function<T, List<T>> children;

    public ArraysToTreeUtil<T> parent(Function<T, Object> parent) {
        this.parent = parent;
        return this;
    }

    public ArraysToTreeUtil<T> code(Function<T, Object> code) {
        this.code = code;
        return this;
    }

    public ArraysToTreeUtil<T> children(Function<T, List<T>> children) {
        this.children = children;
        return this;
    }

    /**
     * 数组转树形
     * 无指定父节点，则会按照当前集合查询，查询到当前集合没有找到父节点的则为父节点
     * */
    public List<T> tree(List<T> list){
        List<T> treeList = new ArrayList<>();
        Map<Object, T> codeMap = list.stream().collect(Collectors.toMap(t->code.apply(t), t -> t));
        list.forEach(t -> {
            if(!codeMap.containsKey(parent.apply(t))){
                treeList.add(t);
            }else{
                T parentT = codeMap.get(parent.apply(t));
                children.apply(parentT).add(t);
            }
        });
        return  treeList;
    }

    /**
     * 数组转树形
     * 指定父节点，只查询指定父节点下的数据节点
     * */
    public List<T> tree(List<T> list, Object pid){
        List<T> treeList = new ArrayList<>();
        Map<Object, T> codeMap = list.stream().collect(Collectors.toMap(t->code.apply(t), t -> t));
        list.forEach(t -> {
            if(Objects.equals(pid,parent.apply(t))){
                treeList.add(t);
            }else{
                T parentT = codeMap.get(parent.apply(t));
                if(Objects.nonNull(parentT)){
                    children.apply(parentT).add(t);
                }
            }
        });
        return  treeList;
    }
}

看是否使用懒加载，如果用懒加载封装树的操作就是前端做的，默认展示一级树节点，前端点击某个树节点调用你的后台接口把对应的下一节点数据返回给前端

class 部门{
     子部门 son
}
class  子部门 {
用户   user；
}