快速将有父子关系数据组装成父子list

假如有一组数据 有父子,祖父或者无限极父子关系,可以使用下面的方式快速组装成tree

继承BeanTree

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

public class BeanTree implements Serializable {
    private String id;
    /**
     * parentId为空 或者 -1 即表示 顶级节点
     */
    private String parentId;
    private String parentIds;
    private List<BeanTree> childList = new ArrayList<>();
    public String getParentIds() {
        return parentIds;
    }

    public void setParentIds(String parentIds) {
        this.parentIds = parentIds;
    }



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

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

    public String getId() {
        return id;
    }

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

    public String getParentId() {
        return parentId;
    }

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

2.TreeFastUtils.java

import com.thinkgem.jeesite.modules.course.entity.BeanTree;
import org.apache.commons.collections.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 快速将一些list 组成父子树关系 并且自动拼接parentIds
 *
 * 必须有以下结构
 */
public class TreeFastUtils {

    // list以tree归类
    public static <T extends BeanTree> List<T> getTree(List<T> treeList) {
        List<T> result = new ArrayList<>();
        //获取所有顶级节点
        List<T> treeRoot = getTreeRoot(treeList);
        //移除顶级节点
        treeList.removeAll(treeRoot);
        //遍历获取子节点
        treeRoot.forEach(root -> result.add(getChild(treeList, root)));
        return result;
    }

    /**
     * 获取所有顶级节点
     *
     * @param nodeList
     * @return
     */
    private static <T extends BeanTree> List<T> getTreeRoot(List<T> nodeList) {
        return nodeList.stream().filter(menu -> {
            Boolean flag= (StringUtils.isBlank(menu.getParentId()) || "-1".equals(menu.getParentId()));
            if(flag){
                menu.setParentIds("0,");
            }
            return  flag;
        }).collect(Collectors.toList());
    }


    /**
     * 递归过获取无限级子节点
     *
     * @param nodeList
     * @param menu
     * @return
     */
    private static<T extends BeanTree> T getChild(List<T> nodeList, T menu) {
        List<T> childList = getChildList(nodeList, menu);
        if (CollectionUtils.isNotEmpty(childList)) {
            //移除已经遍历过的节点
            nodeList.removeAll(childList);
//            childList.forEach(child -> menu.getChildList().add(getChild(childList, child)));
            childList.forEach(child -> menu.getChildList().add(getChild(nodeList, child)));
        }
        return menu;
    }

    /**
     * 得到子节点列表
     * parentId为空或者Null 或者为-1 表示顶级节点
     * @param nodeList
     * @param menu 父节点
     * @param <T>
     * @return
     */
    private static  <T extends BeanTree> List<T> getChildList(List<T> nodeList, T menu) {
        return nodeList.stream().filter(menu_ -> {
            Boolean flag= StringUtils.isBlank(menu_.getParentId())? false : menu_.getParentId().equals(menu.getId());
            if(flag){
                menu_.setParentIds(menu.getParentIds() + menu.getId() +",");
            }
            return flag;
        }).collect(Collectors.toList());
    }
}