java遍历树，并得到每条根到叶子节点的路径

1. 求数的所有根到叶子节点的路径，并求出每条路径上节点值（timeoutMillis）的和，输出最大路径上的数值之和（整数值）

输入是一个字符串：

HEAD`0`A,B,C, A`20`END, B`100`END, C`50`D,E, D`80`F, E`150`END, F`30`END
含义为：HEAD为顶点，ABC为A的孩子节点，C的孩子节点为DE，D的孩子节点为F，END代表为叶子节点没有孩子，整数值代表每个节点的timeoutMillis

import java.util.*;
import java.util.stream.Collectors;

class WorkflowNode {
    String nodeId;
    int timeoutMillis;
    List<WorkflowNode> nextNodes;
    boolean initialised;

    public static WorkflowNode load(String value) {
        // Create head node;
        Map<String, WorkflowNode> map = new HashMap<>();
        WorkflowNode head = new WorkflowNode("HEAD", 0, null);
        map.put(head.nodeId, head);

        for (String nodeValue : value.split("\\|")) {
            String[] properties = nodeValue.split("\\`");
            WorkflowNode node = map.get(properties[0]);

            node.timeoutMillis = Integer.parseInt(properties[1]);
            node.initialised = true;

            // Check next nodes
            if (properties[2].equals("END")) {
                continue;
            }
            node.nextNodes = Arrays.stream(properties[2].split(","))
                    .map(p -> new WorkflowNode(p, 0, null))
                    .collect(Collectors.toList());
            node.nextNodes.forEach(p -> map.put(p.nodeId, p));

            map.put(node.nodeId, node);
        }

        return head;
    }

    public WorkflowNode(String nodeId, int timeoutMillis, List<WorkflowNode> nextNodes) {
        this.nodeId = nodeId;
        this.timeoutMillis = timeoutMillis;
        this.nextNodes = nextNodes;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return super.toString();
    }
}

public class Main
{
    public static Map<String, List> map = new HashMap<>();
    
    public static void iteratorNode(WorkflowNode node,Stack<WorkflowNode> nodeStack){
        nodeStack.push(node);
        List<WorkflowNode> childNodes = node.nextNodes;
        if(childNodes==null){
            List<WorkflowNode> list = new ArrayList<WorkflowNode>();
            Iterator<WorkflowNode> iterator = nodeStack.iterator();
            while(iterator.hasNext()){
                list.add(iterator.next());
            }
            map.put(node.nodeId, list);
            return;
        }else{
            Iterator<WorkflowNode> iterator=childNodes.iterator();
            while(iterator.hasNext()){
                WorkflowNode childNode=iterator.next();
                iteratorNode(childNode, nodeStack);
                nodeStack.pop();
            }
        }
        
    }
    
    public static int getPathTime(List list){
        int sumTime=0;
        Iterator<WorkflowNode> iterator = list.iterator();
        while(iterator.hasNext()){
            WorkflowNode node = iterator.next();
            sumTime+=node.timeoutMillis;
        }
        return sumTime;
    }
    
    public static void main(String args[])
    {
//        String value="HEAD`0`A,B,C|A`20`END|B`100`END|C`50`D,E|D`80`F|E`150`END|F`30`END";
//        System.out.println(Arrays.toString(value.split("\\|")));

//        [HEAD`0`A,B,C, A`20`END, B`100`END, C`50`D,E, D`80`F, E`150`END, F`30`END]
Scanner cin = new Scanner(System.in);
        while (cin.hasNext())
        {
            WorkflowNode node = WorkflowNode.load(cin.next());
//            System.out.println(node.nodeId+node.timeoutMillis+node.nextNodes.get(0).nodeId+node.initialised);
            Stack<WorkflowNode> nodeStack=new Stack<>();
            iteratorNode(node, nodeStack);
//            todo 遍历保存路径
            int time = Integer.MIN_VALUE;
            for (Map.Entry<String, List> entry : map.entrySet()) {
                List list = entry.getValue();
                time = Math.max(getPathTime(list),time);
            }
            System.out.println(time);

        }
    }
}