Java生成组织树结构通用方法（未知最大父节点情况下）

背景

        在有次调用同事写的生成组织树结构的方法时，发现该方法必须要已知最大父节点的id情况下才能生成组织树结构，并且该方法使用了递归调用的效率非常低，所以思考再三，自己编写了一套较为通用的方法，方法中大量使用了泛型。

适用范围

        含有表主键和表的父主键的结构

核心代码

1、通用的实体类接口

package org.example.TreeUtils;

import java.util.List;

public interface TreeEntity<T,R> {
    /**
     * 节点主键
     */
    R id();

    /**
     * 父节点主键
     */
    R parentId();

    /**
     * 判断是否是最大父节点，用于递归生成
     */
    boolean isParent();

    /**
     * 插入孩子节点
     */
    void setChildren(List<T> children);

    /**
     * 获取孩子节点
     */
    List<T> getChildren();


}

2、通用的实现方法

        可以只看第一个生成组织树的方法，第二个是无返回值的方法，核心代码是createTreeMap方法

package org.example.TreeUtils;

import java.util.*;

public class TreeUtil {

    /**
     * @param nodes 要生成组织结构树的集合
     * @return 返回组织结构树的集合
     * @Description: TODO 生成组织结构树（有返回方法）
     * @Author: yhj
     * @Date: 2022/10/24 17:14
     */
    public static <T extends TreeEntity<T, R>, R> List<T> createTree(List<T> nodes) {
        //如果集合为空，则不进行操作，以防异常
        if (null == nodes || nodes.size() == 0) {
            return null;
        }
        //生成组织树的Map集合
        Map<R, List<T>> groupNodeMap = createTreeMap(nodes);
        //最终生成组织树存储的集合
        List<T> treeList = new ArrayList<>();
        //遍历获取Map里的值，也就是获取每一个最大节点树
        for (Map.Entry<R, List<T>> entry : groupNodeMap.entrySet()) {
            treeList.addAll(entry.getValue());
        }
        return treeList;
    }

    /**
     * @param nodes 要生成组织树的集合
     * @return void 无返回值
     * @Description: TODO 生成组织结构树（无返回方法）
     * @Author: yhj
     * @Date: 2022/10/24 17:13
     */
    public static <T extends TreeEntity<T, R>, R> void createTreeNoReturn(List<T> nodes) {
        //如果集合为空，则不进行操作，以防异常
        if (null == nodes || nodes.size() == 0) {
            return;
        }
        //生成组织树的Map集合
        Map<R, List<T>> groupNodeMap = createTreeMap(nodes);
        //要删除的集合，以便只留下最大节点树
        List<T> removeList = new ArrayList<>();
        for (T node : nodes) {
            //如果parentId存在map的key，说明该节点是最大节点，不是则删除
            if (!groupNodeMap.containsKey(node.parentId())) {
                removeList.add(node);
            }
        }
        //批量删除
        if (removeList.size() > 0) {
            nodes.removeAll(removeList);
        }
    }

    /**
     * @param nodes 要生成组织树的集合
     * @return 返回最大节点树的map集合
     * @Description: TODO 生成最大节点树的Map集合
     * @Author: yhj
     * @Date: 2022/10/24 16:19
     */
    public static <T extends TreeEntity<T, R>, R> Map<R, List<T>> createTreeMap(List<T> nodes) {
        //分组
        Map<R, List<T>> groupNodeMap = createGroupMap(nodes);
        //遍历集合
        for (T node : nodes) {
            //1：遍历获取每个节点的子节点
            node.setChildren(groupNodeMap.get(node.id()));
            //2：如果存在子节点，则顺带删除map里的数据
            if (null != node.getChildren() && node.getChildren().size() > 0) {
                groupNodeMap.remove(node.id());
            }
        }
        //返回的就是最大节点树的Map
        return groupNodeMap;
    }

    /**
     * @param nodes 要生成组织树的集合
     * @return 返回分组以后的Map的集合
     * @Description: TODO 根据节点的parentId进行分组
     * @Author: yhj
     * @Date: 2022/10/24 16:25
     */
    public static <T extends TreeEntity<T, R>, R> Map<R, List<T>> createGroupMap(List<T> nodes) {
        //普通分组方法，不用JDK1.8的stream流分组方法是因为有空指针异常难以处理
        Map<R, List<T>> groupNodeMap = new HashMap<>();
        //循环分组
        for (T node : nodes) {
            if (groupNodeMap.containsKey(node.parentId())) {
                groupNodeMap.get(node.parentId()).add(node);
            } else {
                List<T> newList = new ArrayList<>();
                newList.add(node);
                groupNodeMap.put(node.parentId(), newList);
            }
        }
        return groupNodeMap;
    }


}

3、使用方法

        需要生成组织树结构的实体类必须实现通用实体类（TreeEntity）

package org.example.TreeUtils;

import java.io.Serializable;
import java.util.List;

public class UserCpOrgs implements TreeEntity<UserCpOrgs, String> {

    private String id;
    private String name;
    private String code;
    private String parentId;
    private List<UserCpOrgs> childrenList;

    public UserCpOrgs() {
    }

    public UserCpOrgs(String id, String name, String code, String parentId) {
        this.id = id;
        this.name = name;
        this.code = code;
        this.parentId = parentId;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getParentId() {
        return parentId;
    }

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

    public List<UserCpOrgs> getChildrenList() {
        return childrenList;
    }

    public void setChildrenList(List<UserCpOrgs> childrenList) {
        this.childrenList = childrenList;
    }

    @Override
    public String toString() {
        return "UserCpOrgs{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", code='" + code + '\'' +
                ", parentId='" + parentId + '\'' +
                ", childrenList=" + childrenList +
                '}';
    }

    @Override
    public String id() {
        return id;
    }

    @Override
    public String parentId() {
        return parentId;
    }

    @Override
    public boolean isParent() {
        return false;
    }

    @Override
    public void setChildren(List<UserCpOrgs> children) {
        this.childrenList = children;
    }

    @Override
    public List<UserCpOrgs> getChildren() {
        return childrenList;
    }

}

4、测试使用代码

package org.example.TreeUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test {

    public static void main(String[] args) {
        Long startTime = System.currentTimeMillis();
        List<UserCpOrgs> userCpOrgs = new ArrayList<>();
        userCpOrgs.add(new UserCpOrgs("~", "最大节点", "1003", ""));
        userCpOrgs.add(new UserCpOrgs("A", "第一个节点", "1003", "~"));
        userCpOrgs.add(new UserCpOrgs("B", "第二个节点", "11003", "A"));
        userCpOrgs.add(new UserCpOrgs("C", "第三个节点", "11004", "A"));
        userCpOrgs.add(new UserCpOrgs("D", "第四个节点", "11005", "B"));
        userCpOrgs.add(new UserCpOrgs("E", "第5个节点", "11006", "Q"));
        userCpOrgs.add(new UserCpOrgs("F", "第6个节点", "11007", "E"));
        userCpOrgs.add(new UserCpOrgs("G", "第7个节点", "11008", "C"));
        userCpOrgs.add(new UserCpOrgs("H", "第8个节点", "11009", "~"));
        userCpOrgs.add(new UserCpOrgs("I", "第9个节点", "11014", ""));
        userCpOrgs.add(new UserCpOrgs("J", "第10个节点", "11024", "I"));
        userCpOrgs.add(new UserCpOrgs("K", "第11个节点", "11025", "A"));
        userCpOrgs.add(new UserCpOrgs("L", "第12个节点", "11026", null));
        userCpOrgs.add(new UserCpOrgs("O", "第13个节点", "11028", null));
        List<UserCpOrgs> treeByGroup = TreeUtil.createTree(userCpOrgs);
        //TreeUtil.createTreeNoReturn(userCpOrgs);
        for (UserCpOrgs u : treeByGroup) {
            System.out.println(u.toString());
        }
        Long endTime = System.currentTimeMillis();
        System.out.println("程序运行时间：" + (endTime - startTime));
    }
}

5、结果

结尾

        如果发现什么问题，或者出现什么BUG，欢迎大家的指点