树的应用方法

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Builder
    public static class Node {
        private String name;
        private String pName;
        private List<Node> node;
    }


    public static List<Node> getNodeList() {
        return Lists.newArrayList(new Node("1", "", new ArrayList<>()),
                new Node("1-2", "1", new ArrayList<>()),
                new Node("1-3", "1", new ArrayList<>()),
                new Node("1-4", "1", new ArrayList<>()),
                new Node("2-5", "1-2", new ArrayList<>()),
                new Node("2-6", "1-2", new ArrayList<>()),
                new Node("3-7", "1-3", new ArrayList<>()));
    }

    // 构建一颗树
    public static Node getNodeTree(List<Node> list) {
        Map<String, List<Node>> childMap = list.stream()
                .collect(Collectors.groupingBy(Node::getPName));
        list.stream().forEach(node -> node.setNode(childMap.getOrDefault(node.getName(), new ArrayList<>())));
        return list.stream().filter(node -> StringUtils.isBlank(node.getPName())).findAny().orElse(null);
    }


    // 获取子树
    public static Node getSubNodeTree(Node node, String nodeName) {
        if (StringUtils.equals(node.getName(), nodeName)) {
            return node;
        }

        for (Node child : node.getNode()) {
            Node n = getSubNodeTree(child, nodeName);
            if (n != null) {
                return n;
            }
        }
        return null;
    }

    // 获取子树的平铺的节点
    public static List<Node> getSubNodeList(Node node, String nodeName) {
        Node node1 = getSubNodeTree(node, nodeName);
        if (node1 == null) {
            return null;
        }
        return getTreeToNodeList(node1);
    }

    // 平铺树，转化为列表
    public static List<Node> getTreeToNodeList(Node node) {
        List<Node> list = Lists.newArrayList(node);

        if (CollectionUtils.isEmpty(node.getNode())) {
            return list;
        }

        for (Node child : node.getNode()) {
            list.addAll(getTreeToNodeList(child));
        }

        return list;
    }


    // 复制树
    public static Node copyNodeTree(Node node) {
        Node newNode = Node.builder().name("new" + node.getName()).node(new ArrayList<>()).build();

        if(CollectionUtils.isEmpty(node.getNode())){
            return node;
        }

        for (Node child : node.getNode()) {
            if (child != null) {
                newNode.getNode().add(copyNodeTree(child));
            }
        }

        return newNode;
    }

     // 穷举所有根节点到叶子节点的的树名字
    public static List<List<Node>> getPathNode(Node node, List<Node> nodes) {
        List<Node> nodeList = new ArrayList<>(nodes);
        nodeList.add(node);
        List<List<Node>> pathList = new ArrayList<>();
        if (CollectionUtils.isEmpty(node.getNode())) {
            pathList.add(nodeList);
            return pathList;
        }
        for (Node child : node.getNode()) {
            pathList.addAll(getPathNode(child, nodeList));
        }
        return pathList;
    }

    public static void main(String[] args) {
        // 构建node-tree
        Node tree = getNodeTree(getNodeList());
        System.out.println("获取node-tree" + tree);

        // 获取子树-有值
        Node n1 = getSubNodeTree(tree, "3-7");
        System.out.println("获取子树3-7" + n1);

        // 获取子树-空的
        Node n2 = getSubNodeTree(tree, "7");
        System.out.println("获取子树7" + n2);

        // 获取平铺的子树列表
        List<Node> list = getSubNodeList(tree, "1-2");
        System.out.println("获取子树1-2的列表 " + list);

        //复刻一颗新树
        Node n3 = copyNodeTree(tree);
        System.out.println("新树" + n3);


        List<List<Node>> n4 = getPathNode(tree,new ArrayList<>());
        System.out.println("所有路径的树列表" + n4);

    }