Java实现公用实体类转Tree结构

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
 
// 树节点类，用于存储树中的每个元素
class TreeNode<T> {
    private T data; // 节点存储的数据
    private List<TreeNode<T>> children = new ArrayList<>(); // 子节点列表
 
    // 构造函数，初始化节点数据
    public TreeNode(T data) {
        this.data = data;
    }
 
    // 添加子节点
    public void addChild(TreeNode<T> child) {
        children.add(child);
    }
 
    // 获取当前节点的数据
    public T getData() {
        return data;
    }
 
    // 获取当前节点的所有子节点
    public List<TreeNode<T>> getChildren() {
        return children;
    }
}
 
// 树构建器类，负责从列表构建树形结构
class TreeBuilder<T> {
    // buildTree方法，构建树形结构
    public TreeNode<T> buildTree(List<T> items, Function<T, String> idExtractor, Function<T, String> parentIdExtractor) {
        // 创建一个映射，将每个节点的ID映射到对应的TreeNode对象
        Map<String, TreeNode<T>> nodeMap = items.stream()
                .map(item -> new TreeNode<>(item)) // 将每个元素转换为TreeNode
                .collect(Collectors.toMap(node -> idExtractor.apply(node.getData()), Function.identity()));
 
        TreeNode<T> root = null; // 用于存储根节点
        
        // 遍历每个元素，建立父子关系
        for (T item : items) {
            String id = idExtractor.apply(item); // 获取当前节点的ID
            String parentId = parentIdExtractor.apply(item); // 获取父节点的ID
            TreeNode<T> node = nodeMap.get(id); // 获取当前节点
            
            if (parentId == null) {
                root = node; // 假设只有一个根节点
            } else {
                TreeNode<T> parentNode = nodeMap.get(parentId); // 获取父节点
                if (parentNode != null) {
                    parentNode.addChild(node); // 将当前节点添加到父节点的子节点列表中
                }
            }
        }
        
        return root; // 返回构建的树的根节点
    }
}

import java.util.Arrays;
import java.util.List;
 
// 实体类，用于表示树节点的数据
class Entity {
    private String id;         // 节点ID
    private String parentId;   // 父节点ID
    private String name;       // 节点名称
 
    // 构造函数
    public Entity(String id, String parentId, String name) {
        this.id = id;
        this.parentId = parentId;
        this.name = name;
    }
 
    // 获取节点ID
    public String getId() {
        return id;
    }
 
    // 获取父节点ID
    public String getParentId() {
        return parentId;
    }
 
    // 获取节点名称
    public String getName() {
        return name;
    }
}
 
// 主程序
public class Main {
    public static void main(String[] args) {
        // 创建实体列表，模拟树形结构
        List<Entity> entities = Arrays.asList(
            new Entity("1", null, "Root"),         // 根节点
            new Entity("2", "1", "Child 1"),       // Child 1, 父节点为Root
            new Entity("3", "1", "Child 2"),       // Child 2, 父节点为Root
            new Entity("4", "2", "Grandchild 1")   // Grandchild 1, 父节点为Child 1
        );
 
        // 创建树构建器实例
        TreeBuilder<Entity> treeBuilder = new TreeBuilder<>();
        
        // 构建树，传入实体列表及提取ID和父ID的函数
        TreeNode<Entity> tree = treeBuilder.buildTree(
            entities,
            Entity::getId,        // 提取ID
            Entity::getParentId   // 提取父ID
        );
 
        // 打印树结构
        printTree(tree, 0);
    }
 
    // 递归打印树结构的辅助方法
    private static void printTree(TreeNode<Entity> node, int level) {
        if (node == null) return; // 如果节点为空，直接返回
 
        // 打印当前节点的名称，缩进显示层级
        System.out.println("  ".repeat(level) + node.getData().getName());
        
        // 递归打印所有子节点
        for (TreeNode<Entity> child : node.getChildren()) {
            printTree(child, level + 1);
        }
    }
}