Difference between thenAccept and thenApply

Question

I'm reading the document on CompletableFuture and The description for thenAccept() is

Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied action.

and for thenApply() is

Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied function.```

Can anyone explain the difference between the two with some simple examples?

score 55 · Answer 1 · answered Jul 18 '17 at 18:17

55

You need to look at the full method signatures:

CompletableFuture<Void>     thenAccept(Consumer<? super T> action)
<U> CompletableFuture<U>    thenApply(Function<? super T,? extends U> fn)

thenAccept takes a Consumer and returns a T=Void CF, i.e. one that does not carry a value, only the completion state.

thenApply on the other hand takes a Function and returns a CF carrying the return value of the function.

answered Jul 18 '17 at 18:17

the8472

40,999
5
70
122

23

If we take it as compare to Stream, thenAccept() is some what similar to forEach (Consumer ) and theApply is similar to map (Function) – Anver Sadhat Nov 22 '18 at 09:02
but why does this function exist? just for the sake of not returning anything? I think `forEach()` has to exist cuz the overhead of array in `map()` is quite significant, however that doesn't apply here. – Minh Nghĩa Jul 31 '23 at 13:56

score 37 · Answer 2 · answered Mar 28 '18 at 12:35

37

thenApply returns result of curent stage whereas thenAccept does not.

Read this article: http://codeflex.co/java-multithreading-completablefuture-explained/

answered Mar 28 '18 at 12:35

ybonda

1,546
25
38

shahaf · Answer 3 · 2020-02-18T22:24:18.993

As the8472 clearly explained, they are differentiate by their output value and args and thus what you can do with them

CompletableFuture.completedFuture("FUTURE")
                    .thenApply(f -> f.toLowerCase())
                    .thenAccept(f -> System.out.println(f))
                    .thenAccept(f -> System.out.println(f))
                    .thenApply(f -> new String("FUTURE"))
                    .thenAccept(f -> System.out.println(f));

future
null
FUTURE

the Apply functions apply another function and pass a future holding a value

the Accept functions consume this value and returns future holding void

score 5 · Answer 4 · answered Jun 25 '20 at 01:57

I would answer this question in the way I remember the difference between the two: Consider the following future.

CompletableFuture<String> completableFuture
  = CompletableFuture.supplyAsync(() -> "Hello");

ThenAccept basically takes a consumer and passes it the result of the computation CompletableFuture<Void>

CompletableFuture<Void> future = completableFuture
  .thenAccept(s -> System.out.println("Computation returned: " + s));

You can associate this with forEach in streams for easy remembering.

Where as thenApply accepts a Function instance, uses it to process the result and returns a Future that holds a value returned by a function:

CompletableFuture<String> future = completableFuture
  .thenApply(s -> s + " World");

You can associate this with map in the streams as it is actually performing a transformation.

Difference between thenAccept and thenApply

4 Answers4

Linked