Java利用递归实现树形结构的工具类

Java利用递归实现树形结构的工具类攻略

简述

树形结构在程序中非常常见，而递归是树形结构处理最基本的方法。因此，利用递归实现树形结构的工具类也是非常有用的。

本攻略将介绍如何使用Java语言利用递归实现树形结构的工具类，包括实现方法及其应用。

实现方法

以下为Java实现树形结构的工具类的核心代码：

public class TreeUtil {
    /**
     * 将列表转化为树形结构
     *
     * @param list 列表数据
     * @param pid  父节点ID
     * @return 树形结构数据
     */
    public static <T extends TreeNode<T>> List<T> buildTree(List<T> list, Object pid) {
        List<T> trees = new ArrayList<>();
        list.forEach(t -> {
            if (pid.equals(t.getParentId())) {
                trees.add(findChildren(t, list));
            }
        });
        return trees;
    }

    /**
     * 递归查找子节点
     *
     * @param tree 节点
     * @param list 列表数据
     * @return 树形结构的节点
     */
    public static <T extends TreeNode<T>> T findChildren(T tree, List<T> list) {
        list.forEach(t -> {
            if (tree.getId().equals(t.getParentId())) {
                if (tree.getChildren() == null) {
                    tree.setChildren(new ArrayList<>());
                }
                tree.getChildren().add(findChildren(t, list));
            }
        });
        return tree;
    }
}

TreeNode是节点的实体类，具体实现如下：

public class TreeNode<T> {
    private Object id;
    private Object parentId;
    private List<T> children;

    // Getters and Setters
}

如上所述，该工具类主要包含以下两个方法：

1. buildTree：将列表转化为树形结构；
2. findChildren：递归查找子节点。

其中，buildTree方法的具体实现为：

• 遍历列表，如果某个节点的ParentId等于传入的pid，则将该节点及其所有子节点加入到树形结构中。

findChildren方法的具体实现为：

• 遍历列表，如果某个节点的ParentId等于传入的节点的id，则递归查找该节点的子节点，并将该节点及其所有子节点加入到树形结构中。

应用示例

这里给出两个树形结构操作的示例：

1. 给出如下的树形结构：

[
    {"id": 1, "parentId": null},
    {"id": 2, "parentId": 1},
    {"id": 3, "parentId": 2},
    {"id": 5, "parentId": 1}
]

使用TreeUtil工具类将其转化为树形结构：

public class Test {
    public static void main(String[] args) {
        List<TreeNode> treeNodeList = new ArrayList<>();
        treeNodeList.add(new TreeNode(1L, null));
        treeNodeList.add(new TreeNode(2L, 1L));
        treeNodeList.add(new TreeNode(3L, 2L));
        treeNodeList.add(new TreeNode(5L, 1L));
        List<TreeNode> treeList = TreeUtil.buildTree(treeNodeList, null);
        System.out.println(JSON.toJSONString(treeList));
    }
}

转化后的树形结构：

[
    {
        "id": 1,
        "parentId": null,
        "children": [
            {
                "id": 2,
                "parentId": 1,
                "children": [
                    {
                        "id": 3,
                        "parentId": 2,
                        "children": []
                    }
                ]
            },
            {
                "id": 5,
                "parentId": 1,
                "children": []
            }
        ]
    }
]

1. 给出如下的树形结构：

[
    {"id": 1, "parentId": null},
    {"id": 2, "parentId": 1},
    {"id": 3, "parentId": 2},
    {"id": 5, "parentId": 1},
    {"id": 7, "parentId": 8},
    {"id": 8, "parentId": null}
]

使用TreeUtil工具类查找id为2的节点的所有子节点：

public class Test {
    public static void main(String[] args) {
        List<TreeNode> treeNodeList = new ArrayList<>();
        treeNodeList.add(new TreeNode(1L, null));
        treeNodeList.add(new TreeNode(2L, 1L));
        treeNodeList.add(new TreeNode(3L, 2L));
        treeNodeList.add(new TreeNode(5L, 1L));
        treeNodeList.add(new TreeNode(7L, 8L));
        treeNodeList.add(new TreeNode(8L, null));
        TreeNode node = new TreeNode(2L, 1L);
        TreeNode result = TreeUtil.findChildren(node, treeNodeList);
        System.out.println(JSON.toJSONString(result.getChildren()));
    }
}

查找后的结果：

[
    {
        "id": 3,
        "parentId": 2,
        "children": []
    }
]

总结

通过上述介绍，我们可以看到，使用Java语言利用递归实现树形结构的工具类可以大大方便我们对树形数据的处理。通过TreeUtil工具类的两个核心方法，我们可以将列表数据转化为树形结构，也可以实现根据指定节点查找子节点的操作，极大地方便了程序开发。