摸鱼三天！我写了一个通用的组建树TreeUtil工具

　　1. 树的简单遍历思路及写法①数据准备
　　Menu实体类/** * @date: 2022/7/25 * @FileName: Menu * @author: Yan * @Des: */@Data@AllArgsConstructor@NoArgsConstructorpublic class Menu {    private Integer id;    private String name;    private Integer parentId;    private List children;    public Menu(Integer id, String name, Integer parentId) {        this.id = id;        this.name = name;        this.parentId = parentId;    }}复制代码
　　创建测试数据List/** * @date: 2022/7/25 * @FileName: TreeController * @author: Yan * @Des: */@RestController@RequestMapping(＂/tree＂)public class TreeController {    public static List getMenus(){        List menus = Arrays.asList(                new Menu(1, ＂A公司＂, 0),                new Menu(2, ＂a销售部＂, 14),                new Menu(3, ＂财税部＂, 1),                new Menu(4, ＂商务部＂, 1),                new Menu(5, ＂综合部＂, 1),                new Menu(6, ＂a销售1部＂, 2),                new Menu(7, ＂a销售2部＂, 2),                new Menu(8, ＂a销售3部＂, 2),                new Menu(9, ＂a销售4部＂, 2),                new Menu(10, ＂b销售部＂, 14),                new Menu(11, ＂b销售1部＂, 10),                new Menu(12, ＂b销售2部＂, 10),                new Menu(13, ＂人事部＂, 1),                new Menu(14, ＂销售部＂, 1));        return menus;    }}复制代码② 使用Lambda的语法糖遍历及制作树
　　在TreeController中，写入：    @RequestMapping    public List getTree(){        List menus = getMenus();        List menusTree = menus.stream()                .filter(menu -> menu.getParentId() == 0)                .map(menu -> {                    menu.setChildren(getChildrens(menu, menus));                    return menu;                })                .collect(Collectors.toList());        return menusTree;    }        public static List getChildrens(Menu root, List allMenus){        List childrenTree = allMenus.stream()                .filter(menu -> Objects.equals(menu.getParentId(), root.getId()))                .peek(menu -> menu.setChildren(getChildrens(menu, allMenus)))                .collect(Collectors.toList());        return childrenTree;    }复制代码③ 查看运行结果
　　可以看到，我们成功的返回了树形结构
　　问题的出现
　　最近看公司项目，经常会碰到一些场景是需要以树形结构展示的，比如说部门树，设备树，分类树等等，但是感觉好像都是需要用到的时候现写的，但是大体的思路是一样的，感觉重复写就有点冗余了，而且对应的树形结构构建又相对麻烦，我就想着抽离一下，做成一个通用的工具类TreeUtil，于是翻了一下别的大佬的文章，学着写了这样的一个工具类。问题的解决2. 制作工具2.1 TreeNode接口
　　TreeNode用来表示每个树节点的抽象，即需要生成树的对象需要实现此接口。/** * @date: 2022/7/25 * @FileName: TreeNode * @author: Yan * @Des: 树节点父类，所有需要使用TreeUtils工具类形成树形结构等操作的节点都需要实现该接口 */public interface TreeNode {    /**     * 获取树结点id     * @return     */    T getTreeNodeId();    /**     * 获取该节点的父节点id     * @return     */    T getParentId();    /**     * 判断该节点是否为根节点，默认判定     * @Des 可以用于简单树的组件     * @return     */    boolean isRoot();    /**     * 自定义父结点的判定规则     * @param rootCondition     * @return     */    boolean isRoot(RC rootCondition);    /**     * 自定义子节点(叶子结点)的判定规则     * @param leafCondition     * @return     */    boolean isChildren(LC leafCondition);    /**     * 判断是否有子节点     * @return     */    boolean hasChild();    /**     * 设置结点的子节点列表     * @param children     */    void setChildren(List<? extends TreeNode> children);    /**     * 获取所有子节点     * @return     */    List<? extends TreeNode> getChildren();    /**     * 获取树的深度     * @return     */    Integer getLevel();    /**     * 设置树的深度     */    void setLevel(Integer level);}复制代码泛型说明：
　　T 主要定义返回值的类型
　　RC(rootCondition) 主要是定义根节点 (也就是父节点) 的自定义判定规则需要用到的参数类型
　　LC(leafCondition) 主要是定义叶子结点（也就是子节点）的自定义判定规则需要用到的参数类型2.2 TreeUtil工具类回调函数——函数式接口
　　用于遍历树作自定义操作使用/** * @date: 2022/7/28 * @FileName: Handle * @author: Yan * @Des:    定义一个函数式接口 */@FunctionalInterfacepublic interface FunctionHandle  {        void callback(N node, Map result);}复制代码泛型说明：
　　N 表示传入回调函数的结点参数类型
　　K 表示结果集的key
　　V 表示结果集的value非Lambda表达式写法（ 适用于所有版本）/** * @date: 2022/7/25 * @FileName: TreeUtils * @author: Yan * @Des: TreeUtils用来生成树形结构，以及获取所有叶子节点等操作 */public class TreeUtils {    /**     * 根据所有树节点列表，按默认条件生成含有所有树形结构的列表     * 主要用于组建简单树形结构     * @param allData 树形节点列表     * @param    节点类型     * @return 树形结构列表     */    public static > List generateTrees(List allData) {        List roots = new ArrayList<>();        // 使用迭代器操作list元素        for (Iterator iterator = allData.iterator(); iterator.hasNext(); ) {            E node = iterator.next();            if (node.isRoot()) {                node.setLevel(0);                // 获取所有的根节点                roots.add(node);                // 从所有节点列表中删除该节点，以免后续重复遍历该节点                iterator.remove();            }        }        roots.forEach(r -> {            getChildren(r, allData);        });        return roots;    }    /**     * 根据所有树节点列表，按自定义条件---->获取符合条件的父节点     * @param allData   所有树形结构结点     * @param rootCondition 父节点的判定规则     * @param  结点类型     * @param  父节点自定义判定方法的参数类型     * @return 按自定义条件获取符合条件的父节点     */    public static , RC> List generateTrees(List allData, RC rootCondition) {        List roots = new ArrayList<>();        // 使用迭代器操作list元素        for (Iterator iterator = allData.iterator(); iterator.hasNext(); ) {            E node = iterator.next();            // 按条件筛选根节点            if (node.isRoot(rootCondition)) {                node.setLevel(0);                // 获取所有的根节点                roots.add(node);                // 从所有节点列表中删除该节点，以免后续重复遍历该节点                iterator.remove();            }        }        // 返回按条件查询到的父节点        return roots;    }    /**     * 给父节点填充叶子结点     * @param parent    父节点     * @param nodes 所有结点集合     * @param    父节点的对象类型     * @param    集合的类型     */    @SuppressWarnings(＂all＂)    public static  void getChildren(T parent, List allData) {        List children = new ArrayList<>();        for (Iterator ite = allData.iterator(); ite.hasNext(); ) {            E node = ite.next();            // 找出与当前父节点关联的叶子结点            if (Objects.equals(node.getParentId(), parent.getTreeNodeId())) {                node.setLevel(parent.getLevel() + 1);                children.add(node);                // 从所有节点列表中删除该节点，以免后续重复遍历该节点                ite.remove();            }        }        System.out.println(children);        // 如果孩子为空，则直接返回,否则继续递归设置孩子的孩子        if (children.isEmpty()) {            return;        }        parent.setChildren(children);        // 继续递归叶子结点的遍历子节点        children.forEach(m -> {            // 递归设置子节点            getChildren(m, allData);        });    }    /**     * 按照自定义的规则，给父节点填充叶子结点     * @param parent    父节点     * @param allData   所有树形结构结点     * @param leafConfition 叶子结点的自定义判定规则的参数类型     * @param    父节点对象类型     * @param    集合类型     * @param   参数类型     */    @SuppressWarnings(＂all＂)    public static , LC> void getChildren(T parent, List allData, LC leafConfition) {        List children = new ArrayList<>();        Object parentId = parent.getTreeNodeId();        for (Iterator ite = allData.iterator(); ite.hasNext(); ) {            E node = ite.next();            // 按自定义条件筛选子节点,null则表示没有自定义条件            if (Objects.isNull(leafConfition) || node.isChildren(leafConfition)){                // 找出与当前父节点关联的叶子结点                if (Objects.equals(node.getParentId(), parentId)) {                    node.setLevel(parent.getLevel() + 1);                    children.add(node);                    // 从所有节点列表中删除该节点，以免后续重复遍历该节点                    ite.remove();                }            }        }        // 如果孩子为空，则直接返回,否则继续递归设置孩子的孩子        if (children.isEmpty()) {            return;        }        parent.setChildren(children);        // 继续递归叶子结点的遍历子节点        children.forEach(m -> {            // 递归设置子节点            getChildren(m, allData);        });    }    /**     * 根据获取特定结点的子树，通过isParent来判断是否需要父节点     * @param root  根节点（子节点）     * @param allData   全部结点数据     * @param isParent  是否需要父节点     * @param    结点的对象类型     * @return     */    public static > List getTreeByNode(T root, List allData, boolean isParent){        List tree = new ArrayList<>();        if (isParent){            root.setLevel(0);            tree.add(root);            // 包含父节点            // 填充叶子结点            tree.forEach(child -> getChildren(child, allData));            return tree;        } else {            // 不含父节点            // 填充叶子结点            getChildren(root, allData);            return root.getChildren();        }    }    public static void main(String[] args) {        Boolean test = null;    }    /**     * 根据获取特定结点的子树，通过isParent来判断是否需要父节点,通过leafConfition来按照自定义的规则给父节点填充子节点     * @param root  根节点（子节点）     * @param allData   全部结点数据     * @param isParent  是否需要父节点     * @param leafCondition 定义叶子结点的判定参数     * @param    结点的对象类型     * @param   自定义叶子结点的判定参数的对象类型     * @return     */    public static , LC> List getTreeByNode(T root, List allData, boolean isParent, LC leafCondition){        List tree = new ArrayList<>();        if (isParent){            root.setLevel(0);            tree.add(root);            // 包含父节点            // 填充叶子结点            tree.forEach(child -> getChildren(child, allData, leafCondition));            return tree;        } else {            // 不含父节点            // 填充叶子结点            getChildren(root, allData, leafCondition);            return root.getChildren();        }    }    /**     * 根据结点id获取特定结点的子树，通过isParent来判断是否需要父节点     * @param rootId    结点id     * @param allData   所有结点数据     * @param isParent  是否需要父结点     * @param    结点id的对象类型     * @param    集合的类型     * @return     */    public static > List getTreeByNodeId(T rootId, List allData, boolean isParent){        List tree = new ArrayList<>();        E root = null;        for (Iterator iterator = allData.iterator(); iterator.hasNext(); ){            E node = iterator.next();            if (rootId.equals(node.getTreeNodeId())){                node.setLevel(0);                tree.add(node);                root = node;                iterator.remove();            }        }        System.out.println(root);        // 是否需要父节点        if (isParent){            // 需要父节点            // 填充叶子结点            tree.forEach(child -> getChildren(child, allData));            return tree;        } else {            // 不需要父节点            // 填充叶子结点            getChildren(root, allData);            return root.getChildren();        }    }    /**     * 根据结点id获取特定结点的子树，通过isParent来判断是否需要父节点     * @param rootId    结点id     * @param allData   所有结点数据     * @param isParent  是否需要父结点     * @param leafCondition 定义叶子结点的判定参数     * @param    结点id的对象类型     * @param    集合的类型     * @param   自定义叶子结点的判定参数的对象类型     * @return     */    public static , LC> List getTreeByNodeId(T rootId, List allData, boolean isParent, LC leafCondition){        List tree = new ArrayList<>();        E root = null;        for (Iterator iterator = allData.iterator(); iterator.hasNext(); ){            E node = iterator.next();            if (Objects.equals(rootId, node.getTreeNodeId())){                root.setLevel(0);                tree.add(node);                root = node;                iterator.remove();            }        }        System.out.println(root);        // 是否需要父节点        if (isParent){            // 需要父节点            // 填充叶子结点            tree.forEach(child -> getChildren(child, allData, leafCondition));            return tree;        } else {            // 不需要父节点            // 填充叶子结点            getChildren(root, allData, leafCondition);            return root.getChildren();        }    }    /**     * 遍历树型结构，并且根据回调函数执行相应的操作处理     * @param tree  树     * @param handle    回调函数     * @param    集合类型     * @param    结果集的key     * @param    结果集的value     * @return  返回一个结果集的map     */    public static , K, V> Map traverseTree(List tree, FunctionHandle handle){        Map resultMap = new HashMap<>();        for (Iterator iterator = tree.iterator(); iterator.hasNext(); ){            E node = iterator.next();            if (handle != null){                handle.callback(node, resultMap);            }            if (node.hasChild()){                recursiveTree(node.getChildren(), resultMap, handle);            }        }        return resultMap;    }    /**     * 递归遍历子树，获取相应的处理结果     * @param children  子树集合     * @param resultMap 结果集     * @param handle    回调函数     * @param    集合类型     */    public static > void recursiveTree(List children, Map resultMap, FunctionHandle handle){        for (Iterator iterator = children.iterator(); iterator.hasNext(); ){            E child = iterator.next();            if (handle != null){                handle.callback(child, resultMap);            }            if (child.hasChild()){                recursiveTree(child.getChildren(), resultMap, handle);            }        }    }}复制代码3. 使用工具① 定义一个类，实现TreeNode接口
　　这里以树形菜单Menu为例
　　根据Menu类创建一个属性一样的的MenuVo类，并且实现TreeNode接口，通过对TreeNode接口方法的实现来让MenuVo变成一个树形节点。/** * @date: 2022/7/26 * @FileName: MenuVo * @author: Yan * @Des: */@Datapublic class MenuVo implements TreeNode {    private Integer id;    private String name;    private Integer parentId;    private Integer Level;    private List children;    public MenuVo(Integer id, String name, Integer parentId) {        this.id = id;        this.name = name;        this.parentId = parentId;    }    @Override    public Integer getTreeNodeId() {        return this.id;    }    @Override    public Integer getParentId() {        return this.parentId;    }    @Override    public boolean isRoot() {        // 默认判定        return Objects.equals(this.parentId, 0);    }    @Override    public boolean isRoot(Boolean rootCondition) {        // 自定义的父节点判定规则        if (rootCondition){            return Objects.equals(this.id, 14);        } else {            // 都不符合就走默认判定条件            return isRoot();        }    }    @Override    public boolean isChildren(Integer leafCondition) {        // 自定义结点判定规则        // 这里自定义规则当传入的参数等于1的时候 ——> 要销售部，只要销售部的带有＂a＂的部门名作为子树节点        if (leafCondition.equals(1)){            if (this.name.contains(＂a＂)){                return true;            } else {                return false;            }        } else {            // 都不符合就表示该节点不是自定义规则中要的结点            return false;        }    }    @Override    public boolean hasChild() {        return !Objects.isNull(this.children);    }    @Override    public void setChildren(List children) {        this.children = children;    }    @Override    public List getChildren(){        return this.children;    }}复制代码② 数据准备    // 获取测试数据    public static List getMenusVo(){        List menus = Arrays.asList(                new MenuVo(1, ＂A公司＂, 0),                new MenuVo(2, ＂a销售部＂, 14),                new MenuVo(3, ＂财税部＂, 1),                new MenuVo(4, ＂商务部＂, 1),                new MenuVo(5, ＂综合部＂, 1),                new MenuVo(6, ＂a销售1部＂, 2),                new MenuVo(7, ＂a销售2部＂, 2),                new MenuVo(8, ＂a销售3部＂, 2),                new MenuVo(9, ＂a销售4部＂, 2),                new MenuVo(10, ＂b销售部＂, 14),                new MenuVo(11, ＂b销售1部＂, 10),                new MenuVo(12, ＂b销售2部＂, 10),                new MenuVo(13, ＂人事部＂, 1),                new MenuVo(14, ＂销售部＂, 1));        return menus;    }复制代码③ 按照业务需求进行使用
　　创建一个Controller，发送相应的请求，查看返回结果    @GetMapping(＂/test＂)    public List