上一篇文章，講述了Future模式的機制、缺點，CompletableFuture產生的由來、靜態工廠方法、complete()方法等等。
本文將繼續整理CompletableFuture的特性。
3.3 轉換
我們可以通過CompletableFuture來非同步獲取一組資料，並對資料進行一些轉換，類似RxJava、Scala的map、flatMap操作。
3.3.1 map
| 方法名 | 描述 |
|---|---|
| thenApply(Function<? super T,? extends U> fn) | 接受一個Function<? super T,? extends U>引數用來轉換CompletableFuture |
| thenApplyAsync(Function<? super T,? extends U> fn) | 接受一個Function<? super T,? extends U>引數用來轉換CompletableFuture，使用ForkJoinPool |
| thenApplyAsync(Function<? super T,? extends U> fn, Executor executor) | 接受一個Function<? super T,? extends U>引數用來轉換CompletableFuture，使用指定的執行緒池 |
thenApply的功能相當於將CompletableFuture<T>轉換成CompletableFuture<U>。
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
future = future.thenApply(new Function<String, String>() {
@Override
public String apply(String s) {
return s + " World";
}
}).thenApply(new Function<String, String>() {
@Override
public String apply(String s) {
return s.toUpperCase();
}
});
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}複製程式碼再用lambda表示式簡化一下
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
.thenApply(s -> s + " World").thenApply(String::toUpperCase);
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}複製程式碼執行結果：
HELLO WORLD複製程式碼下面的例子，展示了資料流的型別經歷瞭如下的轉換：String -> Integer -> Double。
CompletableFuture<Double> future = CompletableFuture.supplyAsync(() -> "10")
.thenApply(Integer::parseInt)
.thenApply(i->i*10.0);
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}複製程式碼執行結果：
100.0複製程式碼3.3.2 flatMap
| 方法名 | 描述 |
|---|---|
| thenCompose(Function<? super T, ? extends CompletionStage<U>> fn) | 在非同步操作完成的時候對非同步操作的結果進行一些操作，並且仍然返回CompletableFuture型別。 |
| thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn) | 在非同步操作完成的時候對非同步操作的結果進行一些操作，並且仍然返回CompletableFuture型別。使用ForkJoinPool。 |
| thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn,Executor executor) | 在非同步操作完成的時候對非同步操作的結果進行一些操作，並且仍然返回CompletableFuture型別。使用指定的執行緒池。 |
thenCompose可以用於組合多個CompletableFuture，將前一個結果作為下一個計算的引數，它們之間存在著先後順序。
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
.thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " World"));
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}複製程式碼執行結果：
Hello World複製程式碼下面的例子展示了多次呼叫thenCompose()
CompletableFuture<Double> future = CompletableFuture.supplyAsync(() -> "100")
.thenCompose(s -> CompletableFuture.supplyAsync(() -> s + "100"))
.thenCompose(s -> CompletableFuture.supplyAsync(() -> Double.parseDouble(s)));
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}複製程式碼執行結果：
100100.0複製程式碼3.4 組合
| 方法名 | 描述 |
|---|---|
| thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn) | 當兩個CompletableFuture都正常完成後，執行提供的fn，用它來組合另外一個CompletableFuture的結果。 |
| thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn) | 當兩個CompletableFuture都正常完成後，執行提供的fn，用它來組合另外一個CompletableFuture的結果。使用ForkJoinPool。 |
| thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn, Executor executor) | 當兩個CompletableFuture都正常完成後，執行提供的fn，用它來組合另外一個CompletableFuture的結果。使用指定的執行緒池。 |
現在有CompletableFuture<T>、CompletableFuture<U>和一個函式(T,U)->V，thenCompose就是將CompletableFuture<T>和CompletableFuture<U>變為CompletableFuture<V>。
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "100");
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 100);
CompletableFuture<Double> future = future1.thenCombine(future2, (s, i) -> Double.parseDouble(s + i));
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}複製程式碼執行結果：
100100.0複製程式碼使用thenCombine()之後future1、future2之間是並行執行的，最後再將結果彙總。這一點跟thenCompose()不同。
thenAcceptBoth跟thenCombine類似，但是返回CompletableFuture型別。
| 方法名 | 描述 |
|---|---|
| thenAcceptBoth(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action) | 當兩個CompletableFuture都正常完成後，執行提供的action，用它來組合另外一個CompletableFuture的結果。 |
| thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action) | 當兩個CompletableFuture都正常完成後，執行提供的action，用它來組合另外一個CompletableFuture的結果。使用ForkJoinPool。 |
| thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action, Executor executor) | 當兩個CompletableFuture都正常完成後，執行提供的action，用它來組合另外一個CompletableFuture的結果。使用指定的執行緒池。 |
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "100");
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 100);
CompletableFuture<Void> future = future1.thenAcceptBoth(future2, (s, i) -> System.out.println(Double.parseDouble(s + i)));
try {
future.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}複製程式碼執行結果：
100100.0複製程式碼3.5 計算結果完成時的處理
當CompletableFuture完成計算結果後，我們可能需要對結果進行一些處理。
###3.5.1 執行特定的Action
| 方法名 | 描述 |
|---|---|
| whenComplete(BiConsumer<? super T,? super Throwable> action) | 當CompletableFuture完成計算結果時對結果進行處理，或者當CompletableFuture產生異常的時候對異常進行處理。 |
| whenCompleteAsync(BiConsumer<? super T,? super Throwable> action) | 當CompletableFuture完成計算結果時對結果進行處理，或者當CompletableFuture產生異常的時候對異常進行處理。使用ForkJoinPool。 |
| whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor) | 當CompletableFuture完成計算結果時對結果進行處理，或者當CompletableFuture產生異常的時候對異常進行處理。使用指定的執行緒池。 |
CompletableFuture.supplyAsync(() -> "Hello")
.thenApply(s->s+" World")
.thenApply(s->s+ "\nThis is CompletableFuture demo")
.thenApply(String::toLowerCase)
.whenComplete((result, throwable) -> System.out.println(result));複製程式碼執行結果：
hello world
this is completablefuture demo複製程式碼###3.5.2 執行完Action可以做轉換
| 方法名 | 描述 |
|---|---|
| handle(BiFunction<? super T, Throwable, ? extends U> fn) | 當CompletableFuture完成計算結果或者丟擲異常的時候，執行提供的fn |
| handleAsync(BiFunction<? super T, Throwable, ? extends U> fn) | 當CompletableFuture完成計算結果或者丟擲異常的時候，執行提供的fn，使用ForkJoinPool。 |
| handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor) | 當CompletableFuture完成計算結果或者丟擲異常的時候，執行提供的fn，使用指定的執行緒池。 |
CompletableFuture<Double> future = CompletableFuture.supplyAsync(() -> "100")
.thenApply(s->s+"100")
.handle((s, t) -> s != null ? Double.parseDouble(s) : 0);
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}複製程式碼執行結果：
100100.0複製程式碼在這裡，handle()的引數是BiFunction，apply()方法返回R，相當於轉換的操作。
@FunctionalInterface
public interface BiFunction<T, U, R> {
/**
* Applies this function to the given arguments.
*
* @param t the first function argument
* @param u the second function argument
* @return the function result
*/
R apply(T t, U u);
/**
* Returns a composed function that first applies this function to
* its input, and then applies the {@code after} function to the result.
* If evaluation of either function throws an exception, it is relayed to
* the caller of the composed function.
*
* @param <V> the type of output of the {@code after} function, and of the
* composed function
* @param after the function to apply after this function is applied
* @return a composed function that first applies this function and then
* applies the {@code after} function
* @throws NullPointerException if after is null
*/
default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t, U u) -> after.apply(apply(t, u));
}
}複製程式碼而whenComplete()的引數是BiConsumer，accept()方法返回void。
@FunctionalInterface
public interface BiConsumer<T, U> {
/**
* Performs this operation on the given arguments.
*
* @param t the first input argument
* @param u the second input argument
*/
void accept(T t, U u);
/**
* Returns a composed {@code BiConsumer} that performs, in sequence, this
* operation followed by the {@code after} operation. If performing either
* operation throws an exception, it is relayed to the caller of the
* composed operation. If performing this operation throws an exception,
* the {@code after} operation will not be performed.
*
* @param after the operation to perform after this operation
* @return a composed {@code BiConsumer} that performs in sequence this
* operation followed by the {@code after} operation
* @throws NullPointerException if {@code after} is null
*/
default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) {
Objects.requireNonNull(after);
return (l, r) -> {
accept(l, r);
after.accept(l, r);
};
}
}複製程式碼所以，handle()相當於whenComplete()+轉換。
###3.5.3 純消費(執行Action)
| 方法名 | 描述 |
|---|---|
| thenAccept(Consumer<? super T> action) | 當CompletableFuture完成計算結果，只對結果執行Action，而不返回新的計算值 |
| thenAcceptAsync(Consumer<? super T> action) | 當CompletableFuture完成計算結果，只對結果執行Action，而不返回新的計算值，使用ForkJoinPool。 |
| thenAcceptAsync(Consumer<? super T> action, Executor executor) | 當CompletableFuture完成計算結果，只對結果執行Action，而不返回新的計算值 |
thenAccept()是隻會對計算結果進行消費而不會返回任何結果的方法。
CompletableFuture.supplyAsync(() -> "Hello")
.thenApply(s->s+" World")
.thenApply(s->s+ "\nThis is CompletableFuture demo")
.thenApply(String::toLowerCase)
.thenAccept(System.out::print);複製程式碼執行結果：
hello world
this is completablefuture demo複製程式碼