Java 如何在一系列可完成的未来中展平列表？

我有这个：

Stream<CompletableFuture<List<Item>>>

---

这在一开始是有效的，不幸的是，它有一个致命的错误：结果流似乎在检索所有项目之前提前终止。

正如我在评论中所写，这是不可能的

考虑一个任意的服务，它将返回一个

CompletableFuture

：

等等，什么？
我现在可以从

可完成的未来中获取任意整数。
这意味着，通过一些工程努力，我可以从一个完整的未来获得所有信息——毕竟，记忆只是一些数字

因此，我们必须得出结论，在不违反时间结构的情况下，像
magic
这样的方法是不可能存在的。

答案是：没有这样的方法，因为它不可能存在。
同意约翰·库恩的观点。当期货仍在执行时，您无法知道它的状态，因此无法从流转换
流

尽管流的输出可以使用下面的代码进行合并-
java流
到
java列表
或

java列表
至
java列表

List output=input.map（CompletableFuture:：join）.collect（toList（））.stream（）
.flatMap（Collection:：stream）.collect（toList（））；
你不能。如果这是可能的，您将知道每个未来将产生多少项目。有可能的是将它变成一个可完成的未来。
Stream<CompletableFuture<Item>>

    ExecutorService pool = Executors.newFixedThreadPool(PARALLELISM);
    Stream<CompletableFuture<List<IncomingItem>>> reload = ... ;

    @SuppressWarnings("unchecked")
    CompletableFuture<List<IncomingItem>> allFutures[] = reload.toArray(CompletableFuture[]::new);
    CompletionService<List<IncomingItem>> queue = new ExecutorCompletionService<>(pool);
    for(CompletableFuture<List<IncomingItem>> item: allFutures) {
        queue.submit(item::get);
    }
    List<IncomingItem> THE_END = new ArrayList<IncomingItem>();
    CompletableFuture<List<IncomingItem>> ender = CompletableFuture.allOf(allFutures).thenApply(whatever -> {
        queue.submit(() -> THE_END);
        return THE_END;
    });
    queue.submit(() -> ender.get());
    Iterable<List<IncomingItem>> iter = () -> new Iterator<List<IncomingItem>>() {
        boolean checkNext = true;
        List<IncomingItem> next = null;
        @Override
        public boolean hasNext() {
            if(checkNext) {
                try {
                    next = queue.take().get();
                } catch (InterruptedException | ExecutionException e) {
                    throw new RuntimeException(e);
                }
                checkNext = false;
            }
            if(next == THE_END || next == null) {
                return false;
            }
            else {
                return true;
            }
        }
        @Override
        public List<IncomingItem> next() {
            if(checkNext) {
                hasNext();
            }
            if(!hasNext()) {
                throw new IllegalStateException();
            }
            checkNext = true;
            return next;
        }
    };
    Stream<IncomingItem> flat = StreamSupport.stream(iter.spliterator(), false).flatMap(List::stream);

CompletableFuture<Integer> getDiceRoll();

Stream<CompletableFuture<List<Object>>> futureList = Stream.of(getDiceRoll().thenApply(n -> List.of(new Object[n])));

<T> Stream<CompletableFuture<T> magic(Stream<CompletableFuture<List<T>>> arg);

int diceRoll = magic(Stream.of(getDiceRoll().thenApply(n -> List.of(new Object[n])))).count();