基于内部值的CompletableFutures和筛选

Question

我现在有点困惑，所以我有一个方法应该返回CompletableFuture

里面的方法是：

CompletableFuture<List<String>> toReturn = asyncCall().thenApply(....)
.thenCompose(listOfStuff -> convertToList(listOfStuff.stream().map(
     key -> asyncCall2(key)
        .thenApply(optionalValue -> optionalValue.orElse(null))
).collect(Collectors.toList()));

和转换ToList（）简单地加入期货以转换CompletableFuture

基本上，我的目的是过滤从optionalValue中出现的空值。orElse（null）在最后一行中收集所有列表之前进行筛选是很容易的，但是如果我在之前使用它。collect（收集）它正在研究可完成的未来

我怀疑我可以在代码中进行很多重构。

编辑：

private<T> CompletableFuture<List<T>> convertToList(List<CompletableFuture<T>> toConvert) {
    return CompletableFuture.allOf(toConvert.toArray(new CompletableFuture[toConvert.size()]))
            .thenApply(v -> toConvert.stream()
                    .map(CompletableFuture::join)
                    .collect(Collectors.toList())
            );
}




Answer 1

最好的方法可能是更改convertToList（），这样它就不会返回list的未来，而是流的未来：

private <T> CompletableFuture<Stream<T>> convertToFutureOfStream(List<CompletableFuture<T>> toConvert) {
    return CompletableFuture.allOf(toConvert.stream().toArray(CompletableFuture[]::new))
            .thenApply(
                    v -> toConvert.stream()
                            .map(CompletableFuture::join)
            );
}

这将更加可重用，因为该方法将允许更好的链接，并且不会强制调用方处理列表，同时仍然允许通过简单的收集轻松获取列表。

然后，您可以简单地过滤该流以删除空选项：

CompletableFuture<List<String>> toReturn = asyncCall()
    .thenCompose(listOfStuff -> convertToFutureOfStream(
            listOfStuff.stream()
                    .map(this::asyncCall2)
                    .collect(Collectors.toList())
        )
        .thenApply(stream ->
                stream.filter(Optional::isPresent)
                        .map(Optional::get)
                        .collect(Collectors.toList())
        )

    );

您甚至可以通过更改转换ToFutureOfStream（）以将流作为参数来进一步改进这一点：

private <T> CompletableFuture<Stream<T>> convertToFutureOfStream(Stream<CompletableFuture<T>> stream) {
    CompletableFuture<T>[] futures = stream.toArray(CompletableFuture[]::new);
    return CompletableFuture.allOf(futures)
            .thenApply(v -> Arrays.stream(futures).map(CompletableFuture::join));
}

（不幸的是，由于泛型类型数组，这会引发未经检查的赋值警告）

这就给了

CompletableFuture<List<String>> toReturn = asyncCall()
    .thenCompose(listOfStuff -> convertToFutureOfStream(
                listOfStuff.stream().map(this::asyncCall2)
            )
        .thenApply(stream ->
                stream.filter(Optional::isPresent)
                        .map(Optional::get)
                        .collect(Collectors.toList())
        )

    );