使用Java实现通用树形结构转换工具类：深入解析TreeUtil和TreeNode接口

IT_陈寒

发布于 2025-06-01 13:02:18

31100

代码可运行

运行总次数：0

代码可运行

在实际开发中，树形结构的数据处理是一个常见的需求。例如，组织架构、分类管理、评论回复等，都需要将数据以树形结构展示。本文将深入解析如何使用Java实现一个通用的树形结构转换工具类，包括 TreeUtil 和 TreeNode 接口的设计与实现。

一、TreeNode接口设计

首先，我们需要设计一个 TreeNode 接口，用于约束树节点对象必须具备的一些基本功能和属性。具体包括获取节点ID、父节点ID和子节点列表的方法。

public interface TreeNode<T> {
    T getId(); // 获取节点ID
    T getParentId(); // 获取父节点ID
    void setChildren(List<TreeNode<T>> children); // 设置子节点列表
    List<TreeNode<T>> getChildren(); // 获取子节点列表
}

二、TreeUtil工具类设计

接下来，我们设计一个 TreeUtil 工具类，用于将平铺的数据列表转换为树形结构。主要包括两个方法：buildTree 和 findRootNodes。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TreeUtil {

    /**
     * 将平铺的数据列表转换为树形结构
     * @param nodes 所有节点列表
     * @param rootParentId 根节点的父ID
     * @param <T> 节点ID类型
     * @return 树形结构列表
     */
    public static <T> List<TreeNode<T>> buildTree(List<TreeNode<T>> nodes, T rootParentId) {
        // 创建一个ID到节点的映射
        Map<T, TreeNode<T>> nodeMap = new HashMap<>();
        for (TreeNode<T> node : nodes) {
            nodeMap.put(node.getId(), node);
        }

        // 创建一个用于存储根节点的列表
        List<TreeNode<T>> rootNodes = new ArrayList<>();

        // 遍历所有节点，将节点挂载到其父节点上
        for (TreeNode<T> node : nodes) {
            T parentId = node.getParentId();
            if (rootParentId.equals(parentId)) {
                rootNodes.add(node);
            } else {
                TreeNode<T> parentNode = nodeMap.get(parentId);
                if (parentNode != null) {
                    List<TreeNode<T>> children = parentNode.getChildren();
                    if (children == null) {
                        children = new ArrayList<>();
                        parentNode.setChildren(children);
                    }
                    children.add(node);
                }
            }
        }
        return rootNodes;
    }

    /**
     * 从平铺的数据列表中找到所有根节点
     * @param nodes 所有节点列表
     * @param rootParentId 根节点的父ID
     * @param <T> 节点ID类型
     * @return 根节点列表
     */
    public static <T> List<TreeNode<T>> findRootNodes(List<TreeNode<T>> nodes, T rootParentId) {
        List<TreeNode<T>> rootNodes = new ArrayList<>();
        for (TreeNode<T> node : nodes) {
            if (rootParentId.equals(node.getParentId())) {
                rootNodes.add(node);
            }
        }
        return rootNodes;
    }
}

三、示例：实现TreeNode接口的节点类

为了更好地理解 TreeNode 接口和 TreeUtil 工具类的使用，下面实现一个具体的节点类 CategoryNode。

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

public class CategoryNode implements TreeNode<Long> {
    private Long id;
    private Long parentId;
    private String name;
    private List<TreeNode<Long>> children = new ArrayList<>();

    public CategoryNode(Long id, Long parentId, String name) {
        this.id = id;
        this.parentId = parentId;
        this.name = name;
    }

    @Override
    public Long getId() {
        return id;
    }

    @Override
    public Long getParentId() {
        return parentId;
    }

    @Override
    public void setChildren(List<TreeNode<Long>> children) {
        this.children = children;
    }

    @Override
    public List<TreeNode<Long>> getChildren() {
        return children;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "CategoryNode{" +
                "id=" + id +
                ", parentId=" + parentId +
                ", name='" + name + '\'' +
                ", children=" + children +
                '}';
    }
}

四、示例：使用TreeUtil构建树形结构

接下来，通过示例数据，展示如何使用 TreeUtil 构建树形结构。

import java.util.Arrays;
import java.util.List;

public class TreeUtilExample {

    public static void main(String[] args) {
        List<TreeNode<Long>> nodes = Arrays.asList(
                new CategoryNode(1L, 0L, "Root Node"),
                new CategoryNode(2L, 1L, "Child Node 1"),
                new CategoryNode(3L, 1L, "Child Node 2"),
                new CategoryNode(4L, 2L, "Child Node 1.1"),
                new CategoryNode(5L, 2L, "Child Node 1.2"),
                new CategoryNode(6L, 3L, "Child Node 2.1")
        );

        List<TreeNode<Long>> tree = TreeUtil.buildTree(nodes, 0L);

        for (TreeNode<Long> node : tree) {
            System.out.println(node);
        }
    }
}

运行上述示例代码，输出结果如下：

CategoryNode{id=1, parentId=0, name='Root Node', children=[CategoryNode{id=2, parentId=1, name='Child Node 1', children=[CategoryNode{id=4, parentId=2, name='Child Node 1.1', children=[]}, CategoryNode{id=5, parentId=2, name='Child Node 1.2', children=[]}]}, CategoryNode{id=3, parentId=1, name='Child Node 2', children=[CategoryNode{id=6, parentId=3, name='Child Node 2.1', children=[]}]}]}