Teeing Collectors in Java

Teeing collectors in Java, introduced in Java 12, enable developers to collect data into two separate results simultaneously and then merge them into a single result. This feature is particularly useful when performing multiple operations on a stream of data and subsequently combining the results.

Key Concepts

• Collector Interface: In Java, collectors are used to accumulate elements from a stream into a result. The Collector interface provides various methods for this purpose.
• Teeing Collector: The teeing collector merges two separate collectors into one, allowing you to collect elements in different ways and combine the results.

How It Works

The teeing collector requires:

1. Two collectors to process the stream.
2. A merging function to combine their results.

Syntax

Collector<T, A1, R1> collector1 = Collectors.summingInt(SomeClass::getValue);
Collector<T, A2, R2> collector2 = Collectors.counting();

Collector<T, ?, Pair<R1, R2>> teeingCollector = Collectors.teeing(collector1, collector2, 
    (result1, result2) -> new Pair<>(result1, result2));

Example

Suppose you have a list of integers and want to calculate both the sum and the count:

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        var result = numbers.stream().collect(
            Collectors.teeing(
                Collectors.summingInt(Integer::intValue),
                Collectors.counting(),
                (sum, count) -> "Sum: " + sum + ", Count: " + count
            )
        );

        System.out.println(result); // Output: Sum: 15, Count: 5
    }
}

Benefits

• Efficiency: The teeing collector processes the stream in a single pass, making it more efficient than collecting results separately.
• Clarity: It provides a clearer and more concise way to combine results from multiple collectors.

Conclusion

Teeing collectors are an advanced feature in Java that simplify the process of collecting and merging results from a stream. By leveraging teeing collectors, developers can write cleaner and more efficient code when handling multiple data aggregation tasks.