无限分类菜单，通过tree遍历叶子节点

package com.javatest.NodeA;

public class TreeNode {

    /** 节点Id */
    private String nodeId;
    /** 父节点Id */
    private String parentId;
    /** 文本内容 */
    private String text;

    /**
     * 构造函数
     *
     * @param nodeId
     *            节点Id
     */
    public TreeNode(String nodeId) {
        this.nodeId = nodeId;
    }

    /**
     * 构造函数
     *
     * @param nodeId
     *            节点Id
     * @param parentId
     *            父节点Id
     */
    public TreeNode(String nodeId, String parentId) {
        this.nodeId = nodeId;
        this.parentId = parentId;
    }

    public String getNodeId() {
        return nodeId;
    }

    public void setNodeId(String nodeId) {
        this.nodeId = nodeId;
    }

    public String getParentId() {
        return parentId;
    }

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

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

}

ManyTreeNode.java

package com.javatest.NodeA;

import java.util.ArrayList;
import java.util.List;

public class ManyTreeNode {

    private TreeNode data;

    private List<ManyTreeNode> childList;

    public ManyTreeNode(TreeNode data) {
        this.data = data;
        this.childList = new ArrayList<ManyTreeNode>();
    }

    public ManyTreeNode(TreeNode data, List<ManyTreeNode> childList) {
        this.data = data;
        this.childList = childList;
    }

    public TreeNode getData() {
        return data;
    }

    public void setData(TreeNode data) {
        this.data = data;
    }

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

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

}

ManyNodeTree.java

package com.javatest.NodeA;

import java.util.ArrayList;
import java.util.List;

public class ManyNodeTree {

    /** 树根 */
    private ManyTreeNode root;


    public ManyNodeTree(String Root) {
        root = new ManyTreeNode(new TreeNode(Root));
    }

    // 生成一个多叉树，根节点为root
    public ManyNodeTree createTree(List<TreeNode> treeNodes, String root) {

        if (treeNodes == null || treeNodes.size() <= 0) {
            return null;
        }

        ManyNodeTree manyNodeTree = new ManyNodeTree(root);
        // 将所有节点添加到多茶树中
        for (TreeNode treeNode : treeNodes) {
            if (treeNode.getParentId().equals(root)) {
                manyNodeTree.getRoot().getChildList().add(new ManyTreeNode(treeNode));
            } else {
                addChild(manyNodeTree.getRoot(), treeNode);
            }
        }
        return manyNodeTree;
    }

    // 向指定多叉树节点添加子节点
    public void addChild(ManyTreeNode manyTreeNode, TreeNode child) {
        for (ManyTreeNode item : manyTreeNode.getChildList()) {
            if (item.getData().getNodeId().equals(child.getParentId())) {
                // 找到对应的父亲
                item.getChildList().add(new ManyTreeNode(child));
                break;
            } else {
                if (item.getChildList() != null && item.getChildList().size() > 0) {
                    addChild(item, child);
                }
            }
        }

    }

    // 遍历多叉树
    public String iteratorTree(ManyTreeNode manyTreeNode) {
        List<String> rsData = new ArrayList<>();
        StringBuilder buffer = new StringBuilder();
        //buffer.append("|");
        if (manyTreeNode != null) {
            for (ManyTreeNode index : manyTreeNode.getChildList()) {
                buffer.append(index.getData().getNodeId() + "
");
                if (index.getChildList() != null && index.getChildList().size() > 0) {
                    buffer.append(iteratorTree(index));
                }else {
                }
            }
        }
        //buffer.append("
");
        return buffer.toString();


    }

    // 遍历叶子节点
    public String getLeafNode(ManyTreeNode manyTreeNode,StringBuilder leafNodes) {
        StringBuilder buffer = new StringBuilder();
        if (manyTreeNode != null) {
            for (ManyTreeNode index : manyTreeNode.getChildList()) {
                //buffer.append(index.getData().getNodeId() + ",");
                if (index.getChildList() != null && index.getChildList().size() > 0) {
                    buffer.append(getLeafNode(index,leafNodes));
                }else {
                    System.out.println("叶子节点"+index.getData().getNodeId());
                    leafNodes.append(index.getData().getNodeId() + ",");
                }
            }
        }
        return leafNodes.toString();
    }


    public ManyTreeNode getRoot() {
        return root;
    }

    public void setRoot(ManyTreeNode root) {
        this.root = root;
    }

    public static void main(String[] args) {
        List<TreeNode> treeNodes = new ArrayList<TreeNode>();
        String Root = "0";

/*
        treeNodes.add(new TreeNode("系统权限管理", "root"));
        treeNodes.add(new TreeNode("用户管理", "系统权限管理"));
        treeNodes.add(new TreeNode("角色管理", "系统权限管理"));
        treeNodes.add(new TreeNode("组管理", "系统权限管理"));
        treeNodes.add(new TreeNode("用户菜单管理", "系统权限管理"));
        treeNodes.add(new TreeNode("角色菜单管理", "系统权限管理"));
        treeNodes.add(new TreeNode("用户权限管理", "系统权限管理"));
        treeNodes.add(new TreeNode("站内信", "root"));
        treeNodes.add(new TreeNode("写信", "站内信"));
        treeNodes.add(new TreeNode("收信", "站内信"));
        treeNodes.add(new TreeNode("草稿", "站内信"));
*/

        treeNodes.add(new TreeNode("1", "0"));
        treeNodes.add(new TreeNode("101", "1"));
        treeNodes.add(new TreeNode("102", "1"));
        treeNodes.add(new TreeNode("103", "1"));
        treeNodes.add(new TreeNode("10101", "101"));
        treeNodes.add(new TreeNode("1010101", "10101"));
        treeNodes.add(new TreeNode("10102", "101"));
        treeNodes.add(new TreeNode("1010102", "10101"));
        treeNodes.add(new TreeNode("10201", "102"));
        treeNodes.add(new TreeNode("1020101", "10201"));


        ManyNodeTree tree = new ManyNodeTree(Root);

        //遍历多叉树
/*        String result = tree.iteratorTree(tree.createTree(treeNodes).getRoot());
        System.out.println(result);*/


        //遍历叶子节点
        StringBuilder leafNodes = new StringBuilder();
        String LeafNode = tree.getLeafNode(tree.createTree(treeNodes,Root).getRoot(),leafNodes);
        System.out.println(leafNodes);

    }

}

参考文章：https://blog.csdn.net/zhangcongyi420/article/details/86604166