将List构建成前台下拉树展示样式

TreeNode.java

import lombok.Data;

import java.util.List;

@Data
public class TreeNode<T> {
    /**
     * 节点编号
     */
    private String id;
    /**
     * 父节点编号
     */
    private String pid;
    /**
     * 节点名称
     */
    private String title;
    /**
     * 数据
     */
    private T data;
    /**
     * 子节点
     */
    private List<TreeNode<T>> children;
}

TreeUtil.java

import TreeNode;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.PropertyAccessorFactory;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author
 * @date
 */
public class TreeUtil {
    /**
     * 将List构建成前台展示树的格式（根节点，层层包含所有子节点）
     * @param list 树形结构列表
     * @param idName 节点编号
     * @param pidName 父节点编号
     * @param titleName 节点名称
     * @param <T>
     * @return
     */
    public static <T> List<TreeNode<T>> buildTree(List<T> list, String idName, String pidName, String titleName) {
        // 将list构建成树节点的样式
        List<TreeNode<T>> treeNodes = buildTreeNodes(list, idName, pidName, titleName);
        // 获取根节点列表
        List<TreeNode<T>> rootNodes = getTreeRootNodes(treeNodes);
        // 迭代递归出根节点下所有子节点
        Map<String, List<TreeNode<T>>> pidGroup = treeNodes.stream().collect(Collectors.groupingBy(TreeNode::getPid));
        Iterator<TreeNode<T>> it = rootNodes.iterator();
        while (it.hasNext()) {
            setChildNodes(pidGroup, it.next());
        }
        return rootNodes;
    }

    /**
     * 获取根节点列表
     * @param list
     * @return
     */
    private static <T> List<TreeNode<T>> getTreeRootNodes(List<TreeNode<T>> list) {
        // 获取所有节点id
        Set<String> idSet = list.stream().map(TreeNode::getId).collect(Collectors.toSet());
        // 筛选出所有根节点（如果父节点不在节点id列表上则表示该节点为父节点）
        List<TreeNode<T>> rootNodes = list.stream().filter(treeNode -> !idSet.contains(treeNode.getPid())).collect(Collectors.toList());
        return rootNodes;
    }

    /**
     * 设置所有子节点
     * @param pidGroupt
     * @param parentNode
     * @param <T>
     */
    private static <T> void setChildNodes(Map<String, List<TreeNode<T>>> pidGroupt, TreeNode<T> parentNode) {
        // 获取父节点直接下挂的所有子节点
        List<TreeNode<T>> children = pidGroupt.get(parentNode.getId());
        if (CollectionUtils.isNotEmpty(children)) {
            // 迭代每个子节点，为每个子节点设置它们直接下挂的所有子节点
            Iterator<TreeNode<T>> iterator = children.iterator();
            while (iterator.hasNext()) {
                setChildNodes(pidGroupt,iterator.next());
            }
            parentNode.setChildren(children);
        }
    }

    /**
     * 将List构建成树节点的样式(多个节点)
     * @param list
     * @param idName
     * @param pidName
     * @param titleName
     * @param <T>
     * @return
     */
    private static <T> List<TreeNode<T>> buildTreeNodes(List<T> list, String idName, String pidName, String titleName) {
        List<TreeNode<T>> treeNodes = new ArrayList<>();
        // 将list构建成树节点的样式
        for (T item:list) {
            treeNodes.add(buildTreeNode(item, idName, pidName, titleName));
        }
        return treeNodes;
    }

    /**
     * 将对象构建成树节点的样式(单个节点)
     * @param obj
     * @param idName
     * @param pidName
     * @param titleName
     * @return
     */
    private static TreeNode buildTreeNode(Object obj, String idName, String pidName, String titleName){
        // 获取对象属性值
        BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(obj);
        TreeNode treeNode = new TreeNode();
        treeNode.setId((String) beanWrapper.getPropertyValue(idName));
        treeNode.setPid((String) beanWrapper.getPropertyValue(pidName));
        treeNode.setTitle((String) beanWrapper.getPropertyValue(titleName));
        treeNode.setData(obj);
        return treeNode;
    }
}