如何在同一个Java流中正确提交和获取多个未来？

我尝试在同一条流中提交并获得10个

Future

s。每一个都需要1秒来处理，我想并行运行它们

我的第一次尝试是

需要10秒（）

，它按顺序运行，需要10秒

我的第二次尝试是

以1秒为单位（）

并行运行，需要1秒。然而，它使用了一个中间的

.collect（Collectors.toList（））.stream（）

，我认为这不是一个好方法

还有其他推荐的方法吗

public class FutureStream {
    private ExecutorService executor = Executors.newFixedThreadPool(10);;

    @Test
    public void takes_10_sec() {
        IntStream.range(0, 10)
                .mapToObj(i -> longTask())
                .map(task -> {
                    try {
                        return task.get();
                    } catch (InterruptedException | ExecutionException e) {
                        throw new RuntimeException(e);
                    }
                })
                .forEach(System.out::println);
    }

    @Test
    public void takes_1_sec() {
        IntStream.range(0, 10)
                .mapToObj(i -> longTask())
                .collect(Collectors.toList())
                .stream()
                .map(task -> {
                    try {
                        return task.get();
                    } catch (InterruptedException | ExecutionException e) {
                        throw new RuntimeException(e);
                    }
                })
                .forEach(System.out::println);
    }

    private Future<String> longTask() {
        return executor.submit(() -> {
            Thread.sleep(1000);
            return Thread.currentThread().getName();
        });
    }
}

公共类未来流{
私有ExecutorService executor=Executors.newFixedThreadPool（10）；；
@试验
公开作废需要10秒（）{
IntStream.range（0,10）
.mapToObj（i->longTask（））
.map（任务->{
试一试{
return task.get（）；
}捕获（中断异常|执行异常e）{
抛出新的运行时异常（e）；
}
})
.forEach（System.out:：println）；
}
@试验
公开作废需要1秒（）{
IntStream.range（0,10）
.mapToObj（i->longTask（））
.collect（收集器.toList（））
.stream（）
.map（任务->{
试一试{
return task.get（）；
}捕获（中断异常|执行异常e）{
抛出新的运行时异常（e）；
}
})
.forEach（System.out:：println）；
}
私人期货交易所{
返回执行者。提交（（）->{
睡眠（1000）；
返回Thread.currentThread（）.getName（）；
});
}
}

流是惰性的，只处理终端操作所需的元素。对于每个元素，在开始下一个元素之前，将处理整个管道（并行流除外）。例如，这种技术允许短路操作

由于您有一个中间

map（）

操作，该操作会阻止所创建未来的结果，因此在创建下一个未来之前，处理它将等待每个未来完成

---

在收集所有这些信息时，确保首先创建所有未来。这是合适的解决方案，因为您需要确保在处理结果之前处理整个流。

流是惰性的，只处理终端操作所需的元素。对于每个元素，在开始下一个元素之前，将处理整个管道（并行流除外）。例如，这种技术允许短路操作

由于您有一个中间

map（）

操作，该操作会阻止所创建未来的结果，因此在创建下一个未来之前，处理它将等待每个未来完成

在收集所有这些信息时，确保首先创建所有未来。这是合适的解决方案，因为您需要确保在处理结果之前处理整个流