帮我写一个Java列表转树通用方法

### 回答1：

可以使用递归来实现列表转树的通用方法，定义一个节点类：class Node {
String data;
List<Node> children;

public Node(String data) {
this.data = data;
this.children = new ArrayList<>();
}

public void addChild(Node childNode) {
this.children.add(childNode);
}
}public static Node convertListToTree(List<String> list) {
Node root = new Node(list.get(0));
List<Node> currentLevelNodes = new ArrayList<>();
currentLevelNodes.add(root);
int index = 1;
while (index < list.size()) {
List<Node> nextLevelNodes = new ArrayList<>();
for (Node node : currentLevelNodes) {
while (index < list.size()) {
String data = list.get(index);
if (data == null) {
break;
} else {
Node childNode = new Node(data);
node.addChild(childNode);
nextLevelNodes.add(childNode);
index++;
}
}
}
currentLevelNodes = nextLevelNodes;
}
return root;
}

### 回答2：
下面是一个Java列表转树的通用方法示例：

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

public class ListToTree {
    public static void main(String[] args) {
        List<Node> nodeList = new ArrayList<>();

        nodeList.add(new Node(1, "Node 1", 0));
        nodeList.add(new Node(2, "Node 2", 0));
        nodeList.add(new Node(3, "Node 3", 1));
        nodeList.add(new Node(4, "Node 4", 1));
        nodeList.add(new Node(5, "Node 5", 2));

        List<Node> tree = convertListToTree(nodeList);
        
        // 打印树形结构
        printTree(tree, 0);
    }

    public static List<Node> convertListToTree(List<Node> list) {
        Map<Integer, Node> nodeMap = new HashMap<>();
        List<Node> treeList = new ArrayList<>();

        for (Node node : list) {
            nodeMap.put(node.getId(), node);
        }

        for (Node node : list) {
            int parentId = node.getParentId();
            Node parentNode = nodeMap.get(parentId);
            if (parentNode != null) {
                parentNode.addChild(node);
            } else {
                treeList.add(node);
            }
        }

        return treeList;
    }

    public static void printTree(List<Node> nodeList, int depth) {
        for (Node node : nodeList) {
            StringBuilder indent = new StringBuilder();
            for (int i = 0; i < depth; i++) {
                indent.append("  ");
            }
            System.out.println(indent.toString() + node.getName());
            printTree(node.getChildren(), depth + 1);
        }
    }

    static class Node {
        private int id;
        private String name;
        private int parentId;
        private List<Node> children;

        public Node(int id, String name, int parentId) {
            this.id = id;
            this.name = name;
            this.parentId = parentId;
            this.children = new ArrayList<>();
        }

        public void addChild(Node child) {
            children.add(child);
        }

        public int getId() {
            return id;
        }

        public String getName() {
            return name;
        }

        public int getParentId() {
            return parentId;
        }

        public List<Node> getChildren() {
            return children;
        }
    }
}

在该示例中，我们定义了一个`Node`类来表示树节点，并提供了一个`List<Node> convertListToTree(List<Node> list)`方法来实现列表转树的功能。使用`Map<Integer, Node>`来构建节点ID和节点对象的映射，然后遍历列表中的每个节点，在映射中找到其父节点并将其添加为父节点的子节点，如果未找到父节点则将其添加到根节点列表中。同时，我们还提供了一个`printTree`方法来打印树形结构。

你可以根据具体的业务需求对`Node`类和转树方法进行适当的修改和扩展。

### 回答3：
可以使用递归的方式编写一个Java列表转树的通用方法。下面是一个示例代码：

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

public class ListToTreeConverter {

    public static List<Node> convertListToTree(List<Node> nodeList) {
        // 使用HashMap来存储节点的引用，以便在构建树时快速定位节点
        Map<Integer, Node> nodeMap = new HashMap<>();

        // 构建树的根节点列表
        List<Node> rootList = new ArrayList<>();

        // 将节点列表添加到HashMap中
        for (Node node : nodeList) {
            nodeMap.put(node.getId(), node);
        }

        // 遍历节点列表，构建树结构
        for (Node node : nodeList) {
            int parentId = node.getParentId();
            // 如果当前节点的父节点ID为0，则认为它是根节点
            if (parentId == 0) {
                rootList.add(node);
            } else {
                // 从HashMap中找到当前节点的父节点，并将当前节点添加到父节点的子节点列表中
                Node parentNode = nodeMap.get(parentId);
                if (parentNode != null) {
                    parentNode.addChild(node);
                }
            }
        }

        return rootList;
    }

    public static void main(String[] args) {
        // 创建一个节点列表
        List<Node> nodeList = new ArrayList<>();
        nodeList.add(new Node(1, 0, "Root"));
        nodeList.add(new Node(2, 1, "Node 1"));
        nodeList.add(new Node(3, 1, "Node 2"));
        nodeList.add(new Node(4, 2, "Node 1-1"));
        nodeList.add(new Node(5, 2, "Node 1-2"));
        nodeList.add(new Node(6, 3, "Node 2-1"));
        nodeList.add(new Node(7, 3, "Node 2-2"));

        // 调用方法转换列表为树
        List<Node> tree = convertListToTree(nodeList);

        // 打印树结构
        printTree(tree, 0);
    }

    public static void printTree(List<Node> nodeList, int level) {
        for (Node node : nodeList) {
            System.out.println(getIndentation(level) + node.getName());
            printTree(node.getChildren(), level + 1);
        }
    }

    public static String getIndentation(int level) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < level; i++) {
            sb.append("   ");
        }
        return sb.toString();
    }
}


class Node {
    private int id;
    private int parentId;
    private String name;
    private List<Node> children;

    public Node(int id, int parentId, String name) {
        this.id = id;
        this.parentId = parentId;
        this.name = name;
        this.children = new ArrayList<>();
    }

    public int getId() {
        return id;
    }

    public int getParentId() {
        return parentId;
    }

    public String getName() {
        return name;
    }

    public List<Node> getChildren() {
        return children;
    }

    public void addChild(Node child) {
        children.add(child);
    }
}

以上的代码实现了一个简单的将列表转换为树的通用方法。可以通过创建节点对象并设置各个节点的ID、父节点ID和名称来构建一个节点列表。然后使用`convertListToTree`方法将节点列表转换为树结构，返回根节点列表。最后，通过调用`printTree`方法可以打印整棵树的结构。