Advice on using CompletableFuture

I would like some advice on good ways to use CompletableFuture.

If I have a list of integers, for each of them, I would like to perform 3 actions, which takes some time. For example, multiply, divide and subtract.

For the result, it should be map, where key is the integer and the value is list that has the result of three actions.

Scenario 1: If I want to write the result to the map once we finish process one integer, then is below the a good way to do it?

for (int x : nums) {
  CompletableFuture<Integer> multiply = CompletableFuture.supplyAsync(() -> multiply(x));
  CompletableFuture<Integer> divide = CompletableFuture.supplyAsync(() -> divide(x));
  CompletableFuture<Integer> subtract = CompletableFuture.supplyAsync(() -> subtract(x));
  
  CompletableFuture<Void> allRequests = CompletableFuture.allOf(multiple, divide, substract);
  
  //iterate the three CompletableFuture and add to the map.
}

Scenario 2: If I want to write the result to the map until all the process is done.

List<CompletableFuture<Void>> allRequests = new ArrayList<>();

for (int x : nums) {
  CompletableFuture<Integer> multiply = CompletableFuture.supplyAsync(() -> multiply(x));
  CompletableFuture<Integer> divide = CompletableFuture.supplyAsync(() -> divide(x));
  CompletableFuture<Integer> subtract = CompletableFuture.supplyAsync(() -> subtract(x));
  
  CompletableFuture<Void> allRequestsPerNum = CompletableFuture.allOf(multiple, divide, substract);

  allRequests.add(allRequestsPerNum);
}

CompletableFuture.allOf(allRequest);

//How am I suppose to build the result?

For scenario 2, it looks like if we call CompletableFuture.allOf inside the for loop, it implies the three actions need to be done before we move to the next number?

You can use the features build into CompletableFuture, untested so there are probably some minor problems. It should give you a decent idea.

    List<CompletableFuture<Void>> allRequests = new ArrayList<>();

    for (int x : nums) {
         allRequests.add(CompletableFuture.allOf(
                CompletableFuture.supplyAsync(() -> multiply(x)).thenApplyAsync(() -> addToMap()),
                CompletableFuture.supplyAsync(() -> divide(x)).thenApplyAsync(() -> addToMap()),
                CompletableFuture.supplyAsync(() -> subtract(x)).thenApplyAsync(() -> addToMap())));
    }
    CompletableFuture.allOf(allRequests.toArray(new CompletableFuture[])).join();

Something like the following should work for you:

As mentioned in the comments, I make no promises that there would be any performance benefit from doing things this way. I also make no promises this is a 'best practice' for doing it.

// Keep all the futures around
final Collection<CompletableFuture<?>> futures = new ArrayList<>();

// And prepare the resulting map
final Map<Integer, List<Integer>> map = new HashMap<>();

for (int x : Arrays.asList(1, 2, 3)) {
    // Create the map value List.
    // Initialise it with some default values so that 'set'
    // works.  Use a concurrent-safe List so that there's
    // no risk of corruption from the async operations.
    final List<Integer> value = new CopyOnWriteArrayList<>(Arrays.asList(0, 0, 0));

    // Put the key and List (not yet ready) into the Map
    map.put(x, value);

    // Add all of your futures to your tracking Collection.
    // Note: each future now includes setting the appropriate
    // entry in the List to that result.
    futures.add(CompletableFuture.supplyAsync(() -> 2 * x)
            .thenAcceptAsync(result -> value.set(0, result)));
    futures.add(CompletableFuture.supplyAsync(() -> 2 / x)
            .thenAcceptAsync(result -> value.set(1, result)));
    futures.add(CompletableFuture.supplyAsync(() -> 2 - x)
            .thenAcceptAsync(result -> value.set(2, result)));
}

// Wait for them all to complete.
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();