Java实现树状结构解析

最近的工作有遇到此需求,如权限树状结构。因为数据库采用的MySQL，其在语义层面对于树状结构的查询支持偏弱。查询了诸多资料，个人感觉靠谱的不多遂萌生了自己写一个的想法。话不多说啊，直接贴代码：

package tree;

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

import org.apache.commons.lang3.builder.EqualsBuilder;

import com.alibaba.fastjson.JSON;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
 * 树形结构解析
 * 
 * @author gewx
 **/
public final class Tree {

    /**
     * 解析数据结构
     * 
     * @author gewx
     * @param nodeList 数据节点集合
     * @return 解析完成后的树状结果
     **/
    public static List<Node> parse(List<Node> nodeList) {
        List<Node> resultList = new ArrayList<>(64);
        nodeList.stream().filter(val -> !hasChild(nodeList, val.getMenuId())).collect(Collectors.toList())
                .forEach(val -> {
                    reverseRecursion(val, nodeList, resultList);
                });

        Set<Node> set = new HashSet<>(32);
        set.addAll(resultList);

        resultList.clear();
        set.stream().forEach(val -> {
            resultList.add(val);
            recursion(val, nodeList);
        });

        return resultList;
    }

    /**
     * 取出某个节点直至末尾叶子节点的数据
     * 
     * @author gewx
     * @param node     叶子节点
     * @param nodeList 数据节点集合
     * @return 解析完成后的树状结果
     **/
    public static void getNodeJson(Node node, List<Node> nodeList) {
        recursion(node, nodeList);
    }

    /**
     * 倒序递归检索所有父节点,由下往上直到所有根节点
     * 
     * @author gewx
     * @param node       末尾叶子节点
     * @param nodeList   数据节点集合
     * @param resultList 根节点集合
     * @return void
     **/
    private static void reverseRecursion(Node node, List<Node> nodeList, List<Node> resultList) {
        List<Node> parentNodeList = nodeList.stream().filter(val -> val.getMenuId().equals(node.getParentId()))
                .collect(Collectors.toList());
        if (parentNodeList.size() != 0) {
            Node parentNode = parentNodeList.get(0);
            reverseRecursion(parentNode, nodeList, resultList);
        } else {
            resultList.add(node);
        }
    }

    /**
     * 递归检索所有子节点
     * 
     * @author gewx
     * @param node     根节点
     * @param nodeList 数据节点集合
     * @return void
     **/
    private static void recursion(Node node, List<Node> nodeList) {
        List<Node> childNodeList = nodeList.stream().filter(val -> val.getParentId().equals(node.getMenuId()))
                .collect(Collectors.toList());
        if (childNodeList.size() != 0) {
            node.setChildren(childNodeList);
            childNodeList.stream().forEach(val -> {
                recursion(val, nodeList);
            });
        }
    }

    /**
     * 是否还存在父级元素,找出末尾叶子节点
     * 
     * @author gewx
     * 
     * @param node   叶子节点
     * @param menuId 节点标记
     * @return boolean true 存在, false 不存在
     **/
    private static boolean hasChild(List<Node> node, String menuId) {
        return node.stream().anyMatch(val -> val.getParentId().equals(menuId));
    }

    /**
     * 叶子节点数据结构,可与库表做一一映射仅需要保持menuId与parentId映射关系即可
     **/
    @Getter
    @Setter
    @ToString
    public static class Node {

        /**
         * 菜单Id
         **/
        private String menuId;

        /**
         * 菜单名称
         **/
        private String menuName;

        /**
         * 菜单类型
         **/
        private String menuType;

        /**
         * 菜单编码
         **/
        private String menuCode;

        /**
         * 菜单URL
         **/
        private String url;

        /**
         * 菜单父级Id
         **/
        public String parentId;

        /**
         * 排序
         **/
        private Integer sortNum;

        /**
         * 子菜单
         **/
        private List<Node> children = new ArrayList<>();

        public Node(String menuId, String menuName, String menuType, String menuCode, String url, String parentId,
                Integer sortNum) {
            this.menuId = menuId;
            this.menuName = menuName;
            this.menuType = menuType;
            this.menuCode = menuCode;
            this.url = url;
            this.parentId = parentId;
            this.sortNum = sortNum;
        }

        @Override
        public final boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }

            Node otherObject = (Node) obj;
            if (getClass() != otherObject.getClass()) {
                return false;
            }

            EqualsBuilder builder = new EqualsBuilder();
            builder.append(this.menuId, otherObject.getMenuId());
            return builder.isEquals();
        }

        @Override
        public final int hashCode() {
            return this.menuId.hashCode() * 31;
        }
    }

    public static void main(String[] args) {
        List<Node> array = new ArrayList<>();
        array.add(new Tree.Node("CODE_00", "用户管理", "M", "0101", "#", "0", 0));
        array.add(new Tree.Node("CODE_01", "管理界面", "M", "0102", "#", "0", 0));
        array.add(new Tree.Node("CODE_02", "权限管理", "C", "010101", "http://www.baidu.com", "CODE_00", 0));
        array.add(new Tree.Node("CODE_03", "内部管理", "C", "010201", "http://www.baidu.com", "CODE_01", 0));

        array.add(new Tree.Node("CODE_04", "内部用户权限", "C", "010201", "http://www.baidu.com", "CODE_02", 0));
        array.add(new Tree.Node("CODE_05", "外部用户权限", "C", "010201", "http://www.baidu.com", "CODE_02", 0));
        array.add(new Tree.Node("CODE_06", "子权限", "C", "010201", "http://www.baidu.com", "CODE_04", 0));
        array.add(new Tree.Node("CODE_07", "子系统内部管理", "C", "010201", "http://www.baidu.com", "CODE_03", 0));

        List<Node> list = Tree.parse(array);
        String val = JSON.toJSONString(list);
        System.out.println(val);

        // 取出当下节点下所有数据
        Node node = new Tree.Node("CODE_01x", "系统管理员", "M", "0101", "#", "0", 0);
        Tree.getNodeJson(node, array);
        System.out.println(JSON.toJSONString(node));
    }
}

解析结果:

[
    {
        "children": [
            {
                "children": [
                    {
                        "children": [],
                        "menuCode": "010201",
                        "menuId": "CODE_07",
                        "menuName": "子系统内部管理",
                        "menuType": "C",
                        "parentId": "CODE_03",
                        "sortNum": 0,
                        "url": "http://www.baidu.com"
                    }
                ],
                "menuCode": "010201",
                "menuId": "CODE_03",
                "menuName": "内部管理",
                "menuType": "C",
                "parentId": "CODE_01",
                "sortNum": 0,
                "url": "http://www.baidu.com"
            }
        ],
        "menuCode": "0102",
        "menuId": "CODE_01",
        "menuName": "管理界面",
        "menuType": "M",
        "parentId": "0",
        "sortNum": 0,
        "url": "#"
    },
    {
        "children": [
            {
                "children": [
                    {
                        "children": [
                            {
                                "children": [],
                                "menuCode": "010201",
                                "menuId": "CODE_06",
                                "menuName": "子权限",
                                "menuType": "C",
                                "parentId": "CODE_04",
                                "sortNum": 0,
                                "url": "http://www.baidu.com"
                            }
                        ],
                        "menuCode": "010201",
                        "menuId": "CODE_04",
                        "menuName": "内部用户权限",
                        "menuType": "C",
                        "parentId": "CODE_02",
                        "sortNum": 0,
                        "url": "http://www.baidu.com"
                    },
                    {
                        "children": [],
                        "menuCode": "010201",
                        "menuId": "CODE_05",
                        "menuName": "外部用户权限",
                        "menuType": "C",
                        "parentId": "CODE_02",
                        "sortNum": 0,
                        "url": "http://www.baidu.com"
                    }
                ],
                "menuCode": "010101",
                "menuId": "CODE_02",
                "menuName": "权限管理",
                "menuType": "C",
                "parentId": "CODE_00",
                "sortNum": 0,
                "url": "http://www.baidu.com"
            }
        ],
        "menuCode": "0101",
        "menuId": "CODE_00",
        "menuName": "用户管理",
        "menuType": "M",
        "parentId": "0",
        "sortNum": 0,
        "url": "#"
    }
]

支持无限级联树，仅需要保证数据结构中menuId与parentId需要存在级联关系即可。个人简单测试过，小伙伴有需要可以再度验证下。