打印层次节点

展示效果：

实现代码 

package com.cus;

import org.springframework.util.CollectionUtils;

import java.util.*;

/**
 * @author lzl
 * @date: 2020-11-13 10:58
 */
public class TestCopy {
    static class Node {
        int id;
        int parentId;
        String name;

        public Node(int id, int parentId, String name) 				{
            this.id = id;
            this.parentId = parentId;
            this.name = name;
        }
    }

    static class NewNode{
        Node node;
        int level;
        List<NewNode> subNodeList;

        public NewNode(Node node){
            this.node = node;
            this.level = 0;
            this.subNodeList = new ArrayList<>();
        }
    }

    public static void main(String[] args) {
        List<Node> nodeList = Arrays.asList(
                new Node(1, 0, "AA"),
                new Node(2, 1, "BB"),
                new Node(3, 1, "CC"),
                new Node(4, 3, "DD"),
                new Node(5, 3, "EE"),
                new Node(6, 2, "FF"),
                new Node(7, 2, "GG"),
                new Node(8, 4, "HH"),
                new Node(9, 5, "II"),
                new Node(10, 0, "JJ"),
                new Node(11, 10, "KK"),
                new Node(12, 10, "LL"),
                new Node(13, 12, "MM"),
                new Node(14, 13, "NN"),
                new Node(15, 14, "OO")
        );
        print(nodeList);
    }

    /**
     * 处理数组中的节点数据
     * @param nodeList
     */
    private static List<NewNode> handleList(List<Node> nodeList){
        List<NewNode> newNodeList = new ArrayList<>();
        for(Node node: nodeList){
            // 判断父节点
            if(node.parentId == 0){
                NewNode newNode = new NewNode(node);
                newNodeList.add(newNode);
            }else {
                addNewNode(node,newNodeList);
            }
        }
        return newNodeList;
    }

    /**
     * 循环加入节点
     * @param node
     * @param newNodeList
     */
    static void addNewNode(Node node,List<NewNode> newNodeList){
        for(NewNode newNode : newNodeList){
            Node node1 = newNode.node;
            List<NewNode> subNodeList = newNode.subNodeList;
            if(node1.id == node.parentId){
                // 新的节点是当前节点的子节点
                NewNode subNewNode = new NewNode(node);
                subNewNode.level = newNode.level + 1;
                subNodeList.add(subNewNode);
            }else {
                addNewNode(node,subNodeList);
            }
        }
    }


    static void printNewNode(List<NewNode> newNodeList){
        if(CollectionUtils.isEmpty(newNodeList)){
            return;
        }
        for(NewNode newNode : newNodeList ){
            int level = newNode.level;
            System.out.println(space(level)+newNode.node.name);
            printNewNode(newNode.subNodeList);
        }
    }

    public static void print(List<Node> nodeList) {
        List<NewNode> newNodeList = handleList(nodeList);
        printNewNode(newNodeList);
    }

    /**
     *  拼接空格循环的数量
     **/
    public static String space(int tableSpace){
        StringBuffer sb = new StringBuffer();
        for(int i = 0 ;i < tableSpace;i++){
            sb.append("  ");
        }
        return sb.toString();
    }

}

 少量数据输出是OK的，大量数据时存在嵌套循环，层级过深时，存在风险