Combining Streams and CompletableFuture in Java 8: Practical Examples

Introduction

Java 8 introduced significant enhancements to the language, including Streams and CompletableFuture. These features facilitate more efficient and expressive coding, particularly when handling collections and asynchronous computations. Combining Streams and CompletableFuture can lead to powerful and elegant solutions to complex problems. This article explores practical examples of how to combine these two features effectively.

Understanding Streams

Streams represent a sequence of elements supporting sequential and parallel aggregate operations. They allow for functional-style operations on collections of objects, such as map, filter, and reduce.

Example: Basic Stream Operations

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> filteredNames = names.stream()
    .filter(name -> name.startsWith("A"))
    .collect(Collectors.toList());

System.out.println(filteredNames); // Output: [Alice]

Understanding CompletableFuture

CompletableFuture is part of Java’s java.util.concurrent package. It represents a future result of an asynchronous computation. It allows you to attach callbacks and combine multiple futures in various ways.

Example: Basic CompletableFuture Usage

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello, World!");
future.thenAccept(System.out::println); // Output: Hello, World!

Combining Streams and CompletableFuture

Combining Streams and CompletableFuture can help process a collection of data asynchronously and handle the results efficiently.

Example 1: Asynchronous Processing of a List

Suppose you have a list of URLs and you want to fetch data from these URLs asynchronously.

List<String> urls = Arrays.asList("http://example.com", "http://example.org", "http://example.net");

List<CompletableFuture<String>> futures = urls.stream()
    .map(url -> CompletableFuture.supplyAsync(() -> fetchDataFromUrl(url)))
    .collect(Collectors.toList());

List<String> results = futures.stream()
    .map(CompletableFuture::join)
    .collect(Collectors.toList());

results.forEach(System.out::println);

In this example, fetchDataFromUrl is a method that fetches data from a given URL. The map operation creates a CompletableFuture for each URL, and join waits for all futures to complete and collects the results.

Example 2: Combining Results of Multiple CompletableFutures

You might need to perform multiple asynchronous operations and combine their results.

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Result 1");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Result 2");

CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(future1, future2);

combinedFuture.thenRun(() -> {
    try {
        String result1 = future1.get();
        String result2 = future2.get();
        System.out.println(result1 + " & " + result2); // Output: Result 1 & Result 2
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
});

Example 3: Handling Errors in Asynchronous Streams

Handling errors gracefully in asynchronous processing is crucial.

List<String> urls = Arrays.asList("http://example.com", "http://example.org", "http://example.net");

List<CompletableFuture<String>> futures = urls.stream()
    .map(url -> CompletableFuture.supplyAsync(() -> fetchDataFromUrl(url))
        .exceptionally(ex -> "Error fetching data"))
    .collect(Collectors.toList());

List<String> results = futures.stream()
    .map(CompletableFuture::join)
    .collect(Collectors.toList());

results.forEach(System.out::println);

In this example, the exceptionally method handles any exceptions that occur during the asynchronous computation, providing a default error message.

Best Practices

1. Avoid Blocking Calls: When using CompletableFuture, avoid blocking calls like join in parallel streams, as they can lead to performance issues.
2. Error Handling: Always handle exceptions in asynchronous operations to prevent unexpected crashes.
3. Combine Wisely: Use allOf or anyOf to combine multiple futures based on your requirements.
4. Performance Considerations: Be mindful of the performance impact of parallel streams and asynchronous tasks, especially in resource-intensive applications.

Conclusion

Combining Streams and CompletableFuture in Java 8 provides a powerful toolset for handling collections and asynchronous computations. By leveraging these features, you can write more concise, readable, and efficient code. The examples provided demonstrate practical ways to combine these features, offering a foundation for incorporating them into your projects. As with any powerful tool, use them wisely and be mindful of best practices to ensure optimal performance and maintainability.