Collectors.groupingBy() group data, supporting further processing by downstream collectors; 2. Collectors.partitioningBy() partitions by boolean conditions; 3. Collectors.joining() splice strings, supporting delimiters, prefixes and suffixes; 4. Numerical collectors such as summarizingInt() provide statistics; 5. Nested combination collectors to achieve complex operations; 6. collectingAndThen() performs final conversion of the results. These advanced collectors can reduce boilerplate code, improve performance, and enhance code readability, making data processing more intuitive and efficient.

Java's Stream API is a powerful tool for processing sequences of elements, and Collectors are the key to aggregating stream results into useful forms. While Collectors.toList() and Collectors.toMap() are the most commonly used, the Collectors utility class offers a rich set of operations that go far beyond these basics. Let's explore some of the more advanced and practical collectors that can simplify your code and Improve readingability.

1. Grouping Data with groupingBy()

One of the most powerful collectors is Collectors.groupingBy() , which partitions elements into groups based on a classification function.

 List<String> words = Arrays.asList("apple", "banana", "cherry", "date");

Map<Integer, List<String>> groupedByLength = words.stream()
    .collect(Collectors.groupingBy(String::length));

// Results: {4=[date], 5=[apple], 6=[banana, cherry]}

You can also apply a downstream collector to further process each group:

 Map<Integer, Long> countByLength = words.stream()
    .collect(Collectors.groupingBy(String::length, Collectors.counting()));

// Results: {4=1, 5=1, 6=2}

This is especially useful for summarizing data—like counting, summing, or averaging within categories.

2. Partitioning with partitioningBy()

When you need to split a stream into two groups based on a boolean condition, use partitioningBy() .

 Map<Boolean, List<Integer>> evenOdd = Arrays.asList(1, 2, 3, 4, 5).stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));

// Result: {false=[1, 3, 5], true=[2, 4]}

Like groupingBy() , it supports downstream collectors:

 Map<Boolean, Integer> sumPartition = Arrays.asList(1, 2, 3, 4, 5).stream()
    .collect(Collectors.partitioningBy(
        n -> n % 2 == 0,
        Collectors.summmingInt(Integer::intValue)
    ));

// Result: {false=9, true=6}

This is ideal for binary categories like pass/fail, active/inactive, etc.

3. Collecting into Strings with joining()

Need to concatenate strings from a stream? Collectors.joining() is clean and efficient.

 List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

String joined = names.stream()
    .collect(Collectors.joining(", ", "Names: ", "."));

// Results: "Names: Alice, Bob, Charlie."

It supports:

• A delimiter ( ", " )
• An optional prefix ( "Names: " )
• An optional suffix ( "." )

Perfect for building readable output or CSV-like strings.

4. Aggregating Numeric Data

Java provides specialized collectors for numeric reduction:

• Collectors.summingInt() , summingLong() , summingDouble()
• Collectors.averagingInt() , etc.
• Collectors.maxBy() , minBy() with Comparator

Example:

 List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

IntSummaryStatistics stats = numbers.stream()
    .collect(Collectors.summarizingInt(Integer::intValue));

// stats.getSum() → 15
// stats.getAverage() → 3.0
// stats.getMax() → 5

summarizingInt() gives you a full statistical snapshot in one pass.

5. Composing Collectors with Nesting

You can compose collectors by nesting them in groupingBy() , partitioningBy() , or mapping() .

For example, group people by city and get only their names:

 Map<String, List<String>> namesByCity = people.stream()
    .collect(Collectors.groupingBy(
        Person::getCity,
        Collectors.mapping(Person::getName, Collectors.toList())
    ));

Or get the average age per department:

 Map<String, Double> avgAgeByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.avagingInt(Employee::getAge)
    ));

This composability makes Collectors extremely flexible.

6. Handling Optional Results with collectingAndThen()

Sometimes you want to perform a final transformation on the result, especially when you know the result won't be null.

 String maxName = names.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.maxBy(String::compareTo),
        Optional::get
    ));

Use this to wrap a collector and apply a finishing function—handy when you want to assert or convert the final result.

Just be cautious: if the inner collector returns an empty Optional , Optional::get will throw!

Final Thoughts

While toList() and toMap() cover many basic cases, diving into the broader Collectors toolbox lets you:

• Reduce boilerplate
• Improve performance (fewer passes over data)
• Write more expressive, functional-style code

These advanced collectors are not just syntactic sugar—they enable declarative, readable data processing that closely mirrors your intent.

Basically, once you start using groupingBy , partitioningBy , and nested collectors, you'll wonder how you lived without them.

The above is the detailed content of Java Stream Collectors: Beyond `toList()` and `toMap()`. For more information, please follow other related articles on the PHP Chinese website!