java8 List模拟树结构

在Java 8中，我们可以使用lambda表达式和Stream API来模拟树结构。下面是一个简单的示例：

首先，我们需要一个节点类，它包含一个值和一个子节点列表：

class TreeNode {
    private String value;
    private List<TreeNode> children = new ArrayList<>();

    public TreeNode(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

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

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

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

接下来，我们需要一个方法来构建树：

public static TreeNode buildTree(List<String> values) {
    TreeNode root = new TreeNode("");
    Map<Integer, TreeNode> levelToNodeMap = new HashMap<>();
    levelToNodeMap.put(0, root);
    for (String value : values) {
        String[] parts = value.split(":");
        int level = Integer.parseInt(parts[0]);
        String nodeValue = parts[1];
        TreeNode node = new TreeNode(nodeValue);
        levelToNodeMap.get(level - 1).addChild(node);
        levelToNodeMap.put(level, node);
    }
    return root.getChildren().get(0);
}

这个方法接受一个字符串列表，其中每个字符串表示一个节点的级别和值，级别用冒号分隔，例如“1:root”表示根节点。该方法返回根节点。

最后，我们可以使用Stream API和lambda表达式来遍历树：

public static void traverse(TreeNode node) {
    System.out.println(node.getValue());
    node.getChildren().stream().forEach(child -> traverse(child));
}

这个方法接受一个节点，打印该节点的值，然后遍历它的子节点并递归调用自己。

使用示例：

List<String> values = Arrays.asList(
        "1:root",
        "2:node1",
        "3:node2",
        "4:node3",
        "2:node4",
        "3:node5",
        "4:node6"
);
TreeNode root = buildTree(values);
traverse(root);

输出结果：

root
node1
node2
node3
node4
node5
node6