Java 如何对可完成的未来任务执行转换

我正试图对可完成的未来任务列表进行一些转换，但由于缺乏经验而面临一些问题。我有一个完整的未来列表，但我没有对它执行进一步的转换

import java.util.*;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.ExecutionException;

public class thenapply {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        List<Integer> list = Arrays.asList(5, 9, 14);

        final int sum = 0;

        List<CompletableFuture<Integer>> ans = new ArrayList<>();

        for (int i = 0; i < list.size(); i++) {

            final int finali = i;

            ans.add(CompletableFuture.supplyAsync(() -> square(list.get(finali))));

        }

        System.out.println(ans.stream()

                .mapToInt(Integer::intValue).sum());

    }

    private static int square(int a) {

        return a * a;

    }

}

import java.util.*；
导入java.util.concurrent.CompletableFuture；
导入java.util.concurrent.ExecutionException；
公开课然后申请{
公共静态void main（字符串[]args）引发InterruptedException、ExecutionException{
List=Arrays.asList（5,9,14）；
最终整数和=0；
List ans=新的ArrayList（）；
对于（int i=0；isquare（list.get（finali）））；
}
System.out.println（ans.stream（）
.mapToInt（Integer:：intValue）.sum（））；
}
专用静态整数平方（整数a）{
返回a*a；
}
}

我知道

.mapToInt（Integer:：intValue）

是错误的，但不知道如何更正它。此外，我读到我们应该使用

allOf

，但我不知道如何在这里实现它

---

请帮助。

您需要等待完成，然后才能进行进一步计算。 因此，与其使用上一个

System.out.println

，不如做点什么

// wait and process individual values
int result = 0;
for (var f : ans) {
    result += f.get();
}
System.out.println(result);

---

您需要等待完成后才能进行进一步计算。 因此，与其使用上一个

System.out.println

，不如做点什么

// wait and process individual values
int result = 0;
for (var f : ans) {
    result += f.get();
}
System.out.println(result);

publicstaticvoidmain（String[]args）抛出InterruptedException、ExecutionException{
List=Arrays.asList（5,9,14）；
最终原子整数和=新原子整数（0）；
int size=list.size（）；
CountDownLatch闩锁=新的CountDownLatch（大小）；
对于（int i=0；i{
int sq=square（list.get（finali））；
加法和加法之和（sq）；
倒计时（）；
});
}
satch.wait（）；
System.out.println（sum.get（））；
}

公共静态void main（字符串[]args）引发InterruptedException、ExecutionException{
List=Arrays.asList（5,9,14）；
最终原子整数和=新原子整数（0）；
int size=list.size（）；
CountDownLatch闩锁=新的CountDownLatch（大小）；
对于（int i=0；i{
int sq=square（list.get（finali））；
加法和加法之和（sq）；
倒计时（）；
});
}
satch.wait（）；
System.out.println（sum.get（））；
}

有很多。例如，可以是

join

，

然后accept

，

然后acceptsync

等

.mapToInt（CompletableFuture:：join）

，但您应该知道，使用

CompletableFuture

执行这种粒度的并行操作效率低，编写起来复杂。例如，

join

，

然后accept

，

然后acceptsync

等

.mapToInt（CompletableFuture:：join）

但您应该知道，使用

CompletableFuture

以这样的粒度执行并行操作与编写复杂一样低效。

错误：不兼容的抛出类型InterruptedException，最后一行的ExecutionException

。@Amul123我修改了我的答案以适应这一点，并删除了不必要的步骤。

错误：不兼容的抛出类型InterruptedException，最后一行的ExecutionException

。@Amul123我修改了我的答案以适应这一点，并删除了不必要的步骤。为什么我们需要使用

CountdownClatch

？做

ans.stream（）.mapToInt（data->data.join）.sum（）

怎么样？它可以工作，但我想确定是否要使用

allOf

并处理异常？join（）是阻塞操作，不应在异步代码中使用。如果我理解正确，请参见@Holger的评论，

System.out.println（sum.get（））

；将等待，直到

锁存.countDown（）

；值为零，即线程中的所有任务都已完成。我得到了

未报告的异常java.loang。InterruptedException:必须捕获或声明为抛出

。我是否应该在

latch.await（）

内部

try

之后添加整个代码块？您是否像在我的文本中一样将“throws InterruptedException”添加到main（）的声明中？为什么我们需要使用

CountDownLatch

？做

ans.stream（）.mapToInt（data->data.join）.sum（）

怎么样？它可以工作，但我想确定是否要使用

allOf

并处理异常？join（）是阻塞操作，不应在异步代码中使用。如果我理解正确，请参见@Holger的评论，

System.out.println（sum.get（））

；将等待，直到

锁存.countDown（）

；值为零，即线程中的所有任务都已完成。我得到了

未报告的异常java.loang。InterruptedException:必须捕获或声明为抛出

。我是否应该在

latch.await（）之后添加整个代码块
inside
try
？您是否像在我的文本中一样将“throws InterruptedException”添加到main（）的声明中？