Grouping and partitioning

For this lesson, we'll focus on the grouping pattern you should recognize in interviews and code reviews: manual grouping with computeIfAbsent, stream grouping with downstream collectors, multi-level grouping, explicit map choices, partitioningBy, and the edge cases around nulls, mutability and output order. Interviewers ask this because the easy version is ten lines, but the real signal is whether you can choose the right bucket value, not always List<T>.

01Picture it first: buckets with a calculator attached

Picture a conveyor belt of orders. A small label maker reads each order and prints the bucket key, maybe the customer ID. The order drops into that customer's bucket, and a small calculator attached to the bucket either stores the order, increments a count, adds the amount or keeps the largest order seen so far.

That is the whole model. The classifier chooses the bucket; the downstream collector chooses what lives inside it.

Fig. 1

Orders flow through a classifier into customer buckets, then a counting downstream collector produces c-1 to 2, c-2 to 1 and c-3 to 3

Notice the two separate decisions. SalesOrder::customerId is not the same choice as Collectors.counting(). If you keep those separate in your head, groupingBy stops looking like magic and starts looking like a map-building loop.

02Grouping under the hood: the loop version

Here's how I'd write the manual version when validation, logging or early exits make a loop clearer than a stream.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

record Order(String id, String customerId, int cents) { }

final class ManualGroupingDemo {
    public static void main(String[] args) {
        List<Order> orders = List.of(
                new Order("o-1", "c-1", 1200),
                new Order("o-2", "c-2", 900),
                new Order("o-3", "c-1", 300)
        );

        Map<String, List<Order>> byCustomer = new HashMap<>();
        for (Order order : orders) {
            byCustomer
                    .computeIfAbsent(order.customerId(), key -> new ArrayList<>())
                    .add(order);
        }

        System.out.println(byCustomer.get("c-1").size()); // 2
        System.out.println(byCustomer.get("c-2").size()); // 1
    }
}

Notice three things:

• computeIfAbsent creates the ArrayList only when the customer is first seen.
• It returns the stored list, so the chained .add(order) mutates the bucket in the map.
• The map stores one list per customer, not one list per order.

The old get, null-check and put version works, but it spreads one idea across five lines. It is also easy to get subtly wrong: forgetting the put, adding to a local list that never reaches the map, or doing the lookup twice with a classifier that is more expensive than it looks.