树型数据筛选实现方案-Java

一、权限/筛选条件

业务场景：
1、人员根据身份的不同对部门有不同的权限
2、前端请求对树节点进行筛选

方案：
1、根据条件，标注好每个节点的权限信息
2、遍历成树状结构
3、递归数据，删除不需要展示的节点

准备实体类

import lombok.Data;
import java.util.List;

/**
 * Tree
 *
 * @author SERVER-ZJ
 * @since 2023/8/31 🔞🈲 22:31
 */
@Data
public class Tree {

    /** 数据id */
    private Long id;

    /** 上级id */
    private Long parentId;

    /** 授权标签 */
    private boolean authorityFlag;

    /** 查询标签 */
    private boolean queryFlag;

    /** 展示标签 */
    private boolean showFlag;

    /** 子节点列表 */
    private List<Tree> children;

    public boolean getShowFlag() {
        return this.authorityFlag && this.queryFlag;
    }
}

工具类

import com.zj.tree.entity.Tree;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * TreeUtils
 *
 * @author SERVER-ZJ
 * @since 2023/8/31 🔞🈲 22:36
 */
public class TreeUtils {

    private final static Long DEFAULT_ROOT_PARENT_ID = 0L;

    /**
     * 树型数据转化
     *
     * @param objList 数据列表
     * @return 树状数据
     */
    public static List<Tree> convertTreeList(List<Tree> objList) {
        List<Tree> nodeTreeList = convertTreeNodeList(objList);
        return nodeTreeList.stream()
                .filter(node -> DEFAULT_ROOT_PARENT_ID.equals(node.getParentId()))
                .collect(Collectors.toList());
    }

    /**
     * 树型节点数据转化
     *
     * @param objList 数据列表
     * @return 树型节点列表
     */
    public static List<Tree> convertTreeNodeList(List<Tree> objList) {
        Map<Long, List<Tree>> nodeByParentMap = objList.stream()
                .collect(Collectors.groupingBy(Tree::getParentId));

        for (Tree node : objList) {
            if (nodeByParentMap.containsKey(node.getId())) {
                node.setChildren(nodeByParentMap.get(node.getId()));
            }
        }
        return objList;
    }
}

Demo

import com.zj.tree.entity.Tree;
import com.zj.tree.utils.TreeUtils;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * Demo
 *
 * @author SERVER-ZJ
 * @since 2023/8/31 🔞🈲 22:36
 */
public class Demo {

    public static void main(String[] args) {
        List<Tree> objList = listTree();

        for (Tree obj : objList) {
            obj.setAuthorityFlag(true);// 根据具体业务场景判断
            obj.setQueryFlag(true);// 根据具体业务场景判断
        }

        List<Tree> treeList = TreeUtils.convertTreeList(objList);
        filterByShowFlag(treeList);

    }

    /**
     * 过滤树状信息
     * @param treeList 树状列表
     */
    private static void filterByShowFlag(List<Tree> treeList) {
        Iterator<Tree> treeNodeIterator = treeList.iterator();
        Tree node;
        while (treeNodeIterator.hasNext()) {
            node = treeNodeIterator.next();
            // 展示该节点，以下节点自动展示
            if (node.getShowFlag()) {
                continue;
            }
            if (node.getChildren() != null && !node.getChildren().isEmpty()) {
                filterByShowFlag(node.getChildren());
                if (!node.getChildren().isEmpty()) {
                    treeNodeIterator.remove();
                }
            } else {
                treeNodeIterator.remove();
            }
        }
    }

    /**
     * 提供树状列表信息
     *
     * @return 数据列表
     */
    private static List<Tree> listTree() {
        return new ArrayList<>();
    }
}