如果需要等待一组未来值而不想阻塞主线程，可以使用 CompletableFuture 类提供的 CompletableFuture.allOf() 方法。该方法接受一组 CompletableFuture 对象并返回一个新的 CompletableFuture，该 CompletableFuture 在所有对象都完成后执行。可以将回调附加到这个 CompletableFuture，以在所有对象都完成后执行。

以下是一个示例代码，演示如何在一组 CompletableFuture 中使用 allOf() 方法：

import java.util.concurrent.*;

public class CompletableFutureExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
            try {
               Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result of Future 1";
        }, executor);

        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
            try {
               Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result of Future 2";
        }, executor);

        CompletableFuture future3 = CompletableFuture.supplyAsync(() -> {
            try {
               Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result of Future 3";
        }, executor);

        CompletableFuture allFutures = CompletableFuture.allOf(future1, future2, future3);

        allFutures.thenRun(() -> {
            try {
                String combinedResult = future1.get() + "\n" + future2.get() + "\n" + future3.get();
                System.out.println(combinedResult);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
            executor.shutdown();
        });

        // wait for all futures to complete
        allFutures.get();
    }
}

在上面的示例中，我们用 CompletableFuture.supplyAsync() 创建了三个 Future。然后，我们使用 CompletableFuture.allOf() 创建了一个 CompletableFuture，使得我们可以等待所有 Future 的完成而不阻塞主线程。在所有未来对象完成时执行回调。然后我们使用 Future.get() 来等待每个 Future 的结果，并将它们组合起来。最后，我们关闭了线程池。