The Collectors.groupingBy is a powerful method in Java’s Stream API that allows grouping of elements in a stream based on a classification function, and it works well with downstream collectors. Here’s how you can use Collectors.groupingBy with downstream collectors effectively.

---

Syntax of Collectors.groupingBy with a Downstream Collector

The key method signature is:

Collectors.groupingBy(Classifier, Downstream)

• Classifier: A function that determines how the elements are grouped (e.g., based on a key derived from the element).
• Downstream Collector: The collector used to process the grouped elements further (e.g., counting, mapping, reducing, collecting to a list, etc.).

---

Example 1: Grouping Elements and Counting Them

To group elements based on a key and count the number of elements in each group:

Map<String, Long> result = items.stream()
    .collect(Collectors.groupingBy(
        item -> item.getCategory(), // Classifier
        Collectors.counting()       // Downstream collector
    ));

• This produces a map where the key is the category, and the value is the count of items in that category.

---

Example 2: Group and Collect as a List

If you want to group the elements and collect them in lists:

Map<String, List<Item>> result = items.stream()
    .collect(Collectors.groupingBy(
        item -> item.getCategory(), // Classifier
        Collectors.toList()         // Downstream collector
    ));

• Groups all elements into lists under their respective categories.

---

Example 3: Group and Use Summarizing Collector

To produce a statistical summary (e.g., count, sum, min, max, average) for each group:

Map<String, DoubleSummaryStatistics> result = items.stream()
    .collect(Collectors.groupingBy(
        item -> item.getCategory(), // Classifier
        Collectors.summarizingDouble(Item::getPrice) // Summarizing collector
    ));

• This gives a map where each group has a DoubleSummaryStatistics object that includes the sum, count, min, max, and average for the prices in that group.

---

Example 4: Group and Reduce Values

To group elements and simultaneously reduce the values for each group:

Map<String, Optional<Item>> result = items.stream()
    .collect(Collectors.groupingBy(
        item -> item.getCategory(),                      // Classifier
        Collectors.reducing((item1, item2) -> 
            item1.getPrice() > item2.getPrice() ? item1 : item2) // Downstream: Find max price
    ));

• This produces a map where each category has an Optional<Item> representing the item with the highest price.

---

Example 5: Multi-Level Grouping

You can nest multiple groupingBy collectors to perform hierarchical grouping:

Map<String, Map<String, List<Item>>> result = items.stream()
    .collect(Collectors.groupingBy(
        Item::getCategory,        // First-level group by category
        Collectors.groupingBy(Item::getType) // Second-level group by type
    ));

• This creates a nested map where the first key is the category, and the value contains another map grouped by type.

---

Practical Example Walkthrough:

If you have a list of strings and want to:

• Group them by their length.
• Collect their counts using Collectors.counting().

Here’s how:

List<String> names = List.of("apple", "banana", "orange", "kiwi", "pear");

Map<Integer, Long> groupedCounts = names.stream()
    .collect(Collectors.groupingBy(
        String::length,       // Classifier: Group by string length
        Collectors.counting() // Downstream collector: Count elements
    ));

System.out.println(groupedCounts);
// Output: {4=2, 5=2, 6=1}

---

Key Points of Using Downstream Collectors:

1. Flexibility: You can use different collectors (e.g., toList, toSet, counting, joining, etc.) to define how grouped elements are processed.
2. Composition: Downstream collectors can be combined, nested, or customized using collectingAndThen or reducing.
3. Extensibility: Custom Collector implementations can be used as downstream collectors for complex use cases.

This approach simplifies processing grouped data and eliminates the need for verbose loops or manual grouping logic.