Question

那就是它。真的找不到更接近的东西。我想实现以下任务链

List<Item> items = Collections.singletonList(new Item("John Smith", "1997-2014"));

Stream<CompletableFuture<List<ScrappingResult>>> scrappingFutures =
    items.stream().map(item ->
        CompletableFuture.supplyAsync(() -> new ScrappingTask(item).call()));

Stream<CompletableFuture<ScrappingResult>> scrappingFuturesUnwrapped =
    scrappingFutures.map(resultsFuture -> ???);

Stream<CompletableFuture<TrimmingResult>> trimmingResults = scrappingFuturesUnwrapped.map(resultFuture ->
    // thenCompose?
    resultFuture.thenCompose(result -> {
        Path clipsDir = Paths.get("./"
            + result.getItem().getName()
            + "/" + result.getItem().getTimespan());

        AtomicInteger clipIdx = new AtomicInteger();

        return result.getVideo().getClips().stream()
            .map(clip -> CompletableFuture.supplyAsync(() ->
                new TrimmingTask(
                    ffmpegPath,
                    result.getVideo().getVideoUrl(),
                    clip,
                    clipsDir.resolve("clip_" + clipIdx.incrementAndGet() + ".mp3")).call())
            );
    });
);

最后一行在语法上并不正确，但我希望传达这个想法。所以，我想做两次像flatMap这样的事情，最后得到Stream<CompletableFuture<TrimmingResult>>。

我该怎么做？

感谢。

Answer 1

如果我不误解你的意图，你只想弄平结果。您可以使用Spliterator懒惰地接收结果＆amp;使用flatMap将Stream合并为展平流，例如：

Stream<CompletableFuture<ScrappingResult>> scrappingFuturesUnwrapped =
               scrappingFutures.flatMap(each -> unwrap(each));

static <T> Stream<? extends CompletableFuture<T>> 
  unwrap(CompletableFuture<? extends List<? extends T>> master) {

    return generate(new Predicate<Consumer<? super CompletableFuture<T>>>() {

        private Iterator<? extends T> cursor;

        @Override
        public boolean test(Consumer<? super CompletableFuture<T>> consumer) {
            cursor = cursor == null ? await().iterator() : cursor;
            if (cursor.hasNext()) {
                consumer.accept(completedFuture(cursor.next()));
                return true;
            }
            return false;
        }

        //                        v--- blocked at the first time
        private List<? extends T> await() {
            try {
                return master.get();
            } catch (InterruptedException | ExecutionException e) {
                throw new CompletionException(e);
            }
        }
    });
}

static <T> Stream<? extends CompletableFuture<T>> 
  generate(Predicate<Consumer<? super CompletableFuture<T>>> generator) {

    long unknownSize = Long.MAX_VALUE;
    return stream(new AbstractSpliterator<CompletableFuture<T>>(unknownSize, 0) {
        public boolean tryAdvance(Consumer<? super CompletableFuture<T>> action) {
            return generator.test(action);
        }
    }, false);
}

摘要

上面的解决方案只是我的第一个想法，在这种情况下它不是最好的方法，你可以用big design first来反思它。然而，即使它是一个糟糕的解决方案，但我会保留在这里，因为它可能会让别人以其他方式思考。有关详细信息，您可以在此处查看@Holger的评论和there。

我承认最好的方法是@Holger在下面说的，因为没有人写下来，请让我记录下去为更多人服务。

Stream<CompletableFuture<ScrappingResult>> scrappingFuturesUnwrapped =
               scrappingFutures.flatMap(each -> each.join().stream())
                               .map(CompletableFuture::completedFuture);

Answer 2

通常，您无法执行此类逆转。在功能类别语言中，您在以下类别之间有两个仿函数：

T --> Stream<T>
Stream<T> --> CompletableFuture<Stream<T>>

你只是在

之间没有仿函数

T --> CompletableFuture<T>
CompletableFuture<T> --> Stream<CompletableFuture<T>>

如果您不想关注外部CompletableFuture和需要Stream语义，则需要某种StreamT monad transfomer。 Java目前没有更高级别的类型支持，所以我不确定（但可能应用一些非标准技巧）可以实现像StreamT

这样的东西

如何转换CompletableFuture <stream <t>＆gt;流<completablefuture <t>＆gt;？

2 个答案:

摘要