Collectors

groupingBy(classifier) produces Map<K, List<T>>; add a downstream for counting, summing, or nested groupingBy for multi-level; use TreeMap::new for sorted keys.

partitioningBy splits elements into exactly two groups (true/false) with both keys guaranteed, while groupingBy creates N groups with only keys that have matching elements.

Collectors.mapping applies a transformation to each element within a group before the downstream collector processes it, letting you group by one field but collect a different projected value.

Collector.of defines a custom collector with five components: supplier creates the container, accumulator adds elements, combiner merges for parallel, finisher transforms the result, and characteristics provide optimization hints.

summaryStatistics() computes count, sum, min, max, and average in a single pass, returning an IntSummaryStatistics (or Long/Double variant) with all five values.

Use toUnmodifiableList (Java 10), Stream.toList() (Java 16), or collectingAndThen wrapping for unmodifiable results that prevent accidental mutation of shared data.

Stream.toList() returns an unmodifiable list, while collect(Collectors.toList()) returns a mutable ArrayList. Swapping one for the other breaks code that mutates the result.

Collectors.joining() concatenates stream elements into a single String with an optional delimiter, prefix, and suffix, handling all edge cases automatically.

Collectors.toMap collects stream elements into a Map by extracting a key and value from each element, with optional merge function for duplicates and map supplier for ordering.

Collectors.teeing runs two collectors on the same stream in one pass and merges their results with a BiFunction, computing two aggregates simultaneously.

StringJoiner is the underlying builder for delimited string concatenation; String.join and Collectors.joining are convenience layers on top of it.

Stream.reduce is a terminal operation for whole-stream aggregation; Collectors.reducing is a Collector for per-group aggregation inside groupingBy.

collectingAndThen applies a finisher transformation after the downstream collector completes, wrapping, unwrapping, or converting the collected result in one step.

`groupingBy(dept, mapping(getCity, toSet()))` groups by department and keeps only the distinct cities per group.

`map(getName).collect(toSet())` collects distinct names into a `Set`, dropping duplicates automatically because a set stores each value only once.

`toCollection(() -> new TreeSet<>(comparing(salary)))` collects employees into a salary-sorted set, but beware: TreeSet uses the comparator for equality.

`toArray(Employee[]::new)` collects a stream into a typed `Employee[]` array, avoiding the untyped `Object[]` that the no-argument `toArray` returns.

`toConcurrentMap` lets a parallel stream collect directly into one thread-safe `ConcurrentHashMap`, avoiding the per-thread-then-merge overhead of `toMap`.

`groupingBy(dept, mapping(city, toSet()))` gives each department its set of unique cities in a single pass.

Sort entrySet by value descending, then collect into a LinkedHashMap to preserve the ranking.

Stream `map.entrySet()`, format each entry to text, and `joining(", ", "[", "]")` stitches them into one bracketed summary.