Stream API with Collections — toList, toSet, toMap, groupingBy

Direct Answer

Stream API + Collectors is the modern way to transform streams into collections. Core collectors: Collectors.toList() — collects to a mutable ArrayList (Java 8-15) or unmodifiable list (Stream.toList() in Java 16+); Collectors.toSet() — mutable HashSet; Collectors.toMap(keyFn, valueFn) — HashMap, throws IllegalStateException on duplicate keys unless you provide a merge function: Collectors.toMap(k, v, (a, b) -> a); Collectors.toUnmodifiableList/Set/Map(...) — immutable variants (Java 10+); Collectors.groupingBy(classifier) — Map<K, List<T>> grouped by classifier; Collectors.groupingBy(classifier, downstream) — composable: groupingBy(Person::getDept, counting()) gives Map<Dept, Long>; Collectors.partitioningBy(predicate) — Map<Boolean, List<T>> (faster than groupingBy with boolean key); Collectors.counting()/summingInt/Long/Double/averagingInt/Long/Double — aggregations as downstream collectors; Collectors.joining(delimiter) — concatenate strings. Modern idiom (Java 16+): stream.toList() instance method returns an unmodifiable list — shorter and more efficient than collect(Collectors.toList()). Pitfalls: (1) toMap throws on duplicate keys by default — always provide a merge function for multi-valued data; (2) groupingBy returns HashMap — order not preserved; use groupingBy(classifier, LinkedHashMap::new, downstream) for insertion order; (3) mutability differs between Collectors.toList() (mutable) and Stream.toList() (immutable) — confusing migration. For interviews: lead with 'Stream + Collectors replaces manual loops with declarative pipelines; groupingBy and toMap are the workhorses; watch for duplicate-key exceptions in toMap'.

Deep Dive & Architecture

compute, merge, computeIfAbsent, and computeIfPresent are Map methods (Java 8+) that atomically combine get + check + put into a single operation, replacing the verbose get-check-put anti-pattern. computeIfAbsent(key, mappingFunction) — if key absent, compute value and put; most-used for lazy initialization of multi-valued maps: map.computeIfAbsent(key, k -> new ArrayList<>()).add(value). computeIfPresent(key, remappingFunction) — if key present, recompute value (or remove if null returned). compute(key, remappingFunction) — recompute regardless of presence (function gets old value or null). merge(key, value, remappingFunction) — if absent, put value; if present, apply function to combine: map.merge(word, 1, Integer::sum) is the idiomatic word-counter. Why they matter: (1) atomic in ConcurrentHashMap — no lost updates from concurrent get-check-put races; (2) less code than if (map.containsKey(k)) map.put(k, ...) else map.put(k, ...); (3) cleaner intent — the operation says what it does. Pitfalls: (1) not atomic in non-concurrent maps (HashMap) — only the API is single-call, not thread-safe; (2) returning null from a remapping function removes the key — surprising; (3) don't recursively modify the map inside the function — undefined behavior; (4) merge doesn't handle null values the same way as compute — read the Javadoc. For interviews: lead with 'replaces get-check-put, atomic in ConcurrentHashMap, idiomatic for multimap lazy-init and counters'.

Stream API + Collectors is the modern way to transform streams into collections. Core collectors: Collectors.toList() — collects to a mutable ArrayList (Java 8-15) or unmodifiable list (Stream.toList() in Java 16+); Collectors.toSet() — mutable HashSet; Collectors.toMap(keyFn, valueFn) — HashMap, throws IllegalStateException on duplicate keys unless you provide a merge function: Collectors.toMap(k, v, (a, b) -> a); Collectors.toUnmodifiableList/Set/Map(...) — immutable variants (Java 10+); Collectors.groupingBy(classifier) — Map<K, List<T>> grouped by classifier; Collectors.groupingBy(classifier, downstream) — composable: groupingBy(Person::getDept, counting()) gives Map<Dept, Long>; Collectors.partitioningBy(predicate) — Map<Boolean, List<T>> (faster than groupingBy with boolean key); Collectors.counting()/summingInt/Long/Double/averagingInt/Long/Double — aggregations as downstream collectors; Collectors.joining(delimiter) — concatenate strings. Modern idiom (Java 16+): stream.toList() instance method returns an unmodifiable list — shorter and more efficient than collect(Collectors.toList()). Pitfalls: (1) toMap throws on duplicate keys by default — always provide a merge function for multi-valued data; (2) groupingBy returns HashMap — order not preserved; use groupingBy(classifier, LinkedHashMap::new, downstream) for insertion order; (3) mutability differs between Collectors.toList() (mutable) and Stream.toList() (immutable) — confusing migration. For interviews: lead with 'Stream + Collectors replaces manual loops with declarative pipelines; groupingBy and toMap are the workhorses; watch for duplicate-key exceptions in toMap'.

A common mistake is confusing the interface with the implementation (e.g., saying List when you mean ArrayList), or not knowing that Map does not extend Collection.

Common Mistakes & Pitfalls

Using Collectors.toList() and assuming the result is unmodifiable (it returns a mutable ArrayList), or not knowing about toUnmodifiableList()