Java 创建任务树

我可以创建一个包含字符串的对象树吗。例如，如下所示

         T1
         |
         T2
         /\
        T3 T4
         \ /
          T5

创建这样的树的语法是什么？我试着让每一个都按顺序、并行和嵌套顺序运行

这是我到目前为止写的：

    public class Tasks {
    public Node node;
    public String put(String value, int[] path){

    Node current = node;

    for(int i=0;i<path.length;i++){
        if(current.children.get(i)==null){
            current.children.add(i, new Node());
        }
        current = current.children.get(i);
    }
    String ret = current.value;
    current.value = value;

   Tasks myTask = new Tasks();
    myTask.node = new Node();
    int[] path1 = {0, 0, 0};
    myTask.put("T1", path1);
    System.out.println(myTask.get(path1));
}

 }

public class Node{
public ArrayList<Node> children;
public Node parent;
public String value;

公共类任务{
公共节点；
公共字符串put（字符串值，int[]路径）{
节点电流=节点；
对于（int i=0；i请使用根据给定树结构组织的和任务查看此示例。它已准备好运行，因此您可以测试它并使用它进行实验：

public class Test {

    public static void main(String[] args) throws Exception {
        // Declare a new ExecutorService with a maximum of 2 threads.
        ExecutorService service = Executors.newFixedThreadPool(2);

        // Declare the tasks.
        StringTask t1 = new StringTask("First task!");
        StringTask t2 = new StringTask("Second task!");
        StringTask t3 = new StringTask("Third task!");
        StringTask t4 = new StringTask("Fourth task!");
        StringTask t5 = new StringTask("Fifth task!");

        // Submit the first task.
        String result1 = service.submit(t1).get(); // Using the .get() directly blocks the waiting for completion of the task.
        System.out.println("T1 result: " + result1);

        // Submit the second task.
        String result2 = service.submit(t2).get();
        System.out.println("T2 result: " + result2);

        // Prepare the list of parallel tasks and invoke them.
        List<StringTask> parallelTasks = new ArrayList<>(2);
        parallelTasks.add(t3);
        parallelTasks.add(t4);
        List<Future<String>> results = service.invokeAll(parallelTasks); // Note that using .invokeAll() will block the
                                                                         // execution until all tasks are completed.
        for (Future<String> result : results) {
            System.out.println("Parallel task result: " + result.get());
        }

        // Submit the last task.
        String result5 = service.submit(t5).get();
        System.out.println("T5 result: " + result5);
    }

    /**
     * Callable task that reverses a given String.
     */
    private static final class StringTask implements Callable<String> {
        private String input;

        private StringTask(String input) {
            super();

            if (input == null) {
                throw new NullPointerException();
            }

            this.input = input;
        }

        @Override
        public String call() throws Exception {
            StringBuilder builder = new StringBuilder();

            for (int i = this.input.length() - 1; i >= 0; i--) {
                builder.append(this.input.charAt(i));
            }

            return builder.toString();
        }
    }
}

公共类测试{
公共静态void main（字符串[]args）引发异常{
//声明一个最多有2个线程的新ExecutorService。
ExecutorService=Executors.newFixedThreadPool（2）；
//声明任务。
StringTask t1=新的StringTask（“第一个任务！”）；
StringTask t2=新的StringTask（“第二个任务！”）；
StringTask t3=新的StringTask（“第三个任务！”）；
StringTask t4=新建StringTask（“第四个任务！”）；
StringTask t5=新StringTask（“第五个任务！”）；
//提交第一个任务。
String result1=service.submit（t1）.get（）；//直接使用.get（）阻止等待任务完成。
System.out.println（“T1结果：+result1”）；
//提交第二个任务。
字符串result2=service.submit（t2.get（）；
System.out.println（“T2结果：+result2”）；
//准备并行任务列表并调用它们。
List parallelTasks=new ArrayList（2）；
添加（t3）；
添加（t4）；
List results=service.invokeAll（parallelstasks）；//注意，使用.invokeAll（）将阻止
//执行，直到所有任务完成。
用于（未来结果：结果）{
System.out.println（“并行任务结果：+result.get（））；
}
//提交最后一个任务。
字符串result5=service.submit（t5.get（）；
System.out.println（“T5结果：+result5”）；
}
/**
*反转给定字符串的可调用任务。
*/
私有静态最终类StringTask实现可调用{
私有字符串输入；
私有字符串任务（字符串输入）{
超级（）；
如果（输入==null）{
抛出新的NullPointerException（）；
}
这个输入=输入；
}
@凌驾
公共字符串调用（）引发异常{
StringBuilder=新的StringBuilder（）；
对于（int i=this.input.length（）-1；i>=0；i--）{
append（this.input.charAt（i））；
}
返回builder.toString（）；
}
}
}

如果您事先知道任务及其组织方式，您可以以类似的方式对其进行硬编码。但是，如果任务结构不是静态的或事先不知道，您可能希望实现自己的任务树结构（例如使用
CallableNode
对象）然后使用一个
ExecutorService
遍历该树，并根据其结构执行任务。
您到底遇到了什么问题？如何创建类？如何实例化它们并相互引用？从技术上讲，您绘制的不是树。可以使用类似于树的表示法来表示它。Th对我来说，e就像一个问题。你为什么要尝试创建这个结构？你需要存储哪些对象？你说你正在尝试使
每一个都按顺序、并行和嵌套顺序运行
-每一个都是什么？请看一看关于编写更好问题的提示。你能提供的信息越多，你能得到的帮助就越多t、 如果我听起来有点含糊，我很抱歉。我试图做的是让每个任务以预定的方式执行某种计算，并发、并行，最后嵌套。字符串是每个任务将持有的内容。“如何实例化它们并相互引用？”是的！……我可以想象一些关于执行器的解决方案。但是首先：你已经有了一些代码可以开始使用了吗？谢谢！我已经开始使用这种方法了。我很快会更新你的！@Christy别忘了你可以调整实现
可调用的
的类（甚至创建不同的类）为了更好地满足你的需要。我的只是一个简单的例子！