Lambdas and streams

A lambda is an implementation of a functional interface — an interface with exactly one abstract method. java.util.function has the common shapes: Function<T, R>, Predicate<T>, Supplier<T>, Consumer<T>, BiFunction<T, U, R>, UnaryOperator<T>, plus primitive versions such as IntPredicate that avoid boxing. A method reference (String::length, System.out::println, ArrayList::new) is shorthand for a lambda that just calls that method.

A lambda can read local variables from the enclosing method only if they are effectively final — never reassigned. The lambda captures the value, not the variable, and may run later or on another thread, so allowing reassignment would make "which value?" ambiguous. Mutating the object a captured variable points to is allowed (and in a stream is usually a bug).

Pipelines are lazy and run element by element

A stream pipeline is a source, zero or more intermediate operations (filter, map, sorted, distinct, limit...) and one terminal operation (collect, toList, forEach, count, findFirst...). Intermediate operations only describe work; nothing runs until the terminal operation pulls elements through. Each element then travels the whole pipeline before the next one starts, and short-circuiting operations like findFirst or limit stop pulling as soon as they have their answer.

1import java.util.*;2import java.util.stream.*;3 4public class Solution {5    public static List<String> describe() {6        List<String> log = new ArrayList<>();7        Stream<Integer> pipeline = Stream.of(1, 2, 3, 4, 5, 6)8            .filter(n -> { log.add("filter " + n); return n % 2 == 0; })9            .map(n -> { log.add("map " + n); return n * 10; });10        log.add("pipeline built");11 12        Optional<Integer> first = pipeline.findFirst();13        log.add("result " + first.orElseThrow());14 15        try {16            pipeline.count();                 // a second terminal operation17        } catch (IllegalStateException e) {18            log.add("reuse: " + e.getMessage());19        }20        return log;21    }22}

A stream can be consumed only once. Calling a second terminal operation on the same stream object throws IllegalStateException; build a new stream from the source instead. Stream.toList() (Java 16) returns an unmodifiable list.

Collecting into maps

Collectors.groupingBy(classifier) builds a Map<K, List<T>>; a second, downstream collector replaces the list: counting(), summingInt(...), mapping(...), maxBy(...). groupingBy makes no promise about the map type or its order (in practice it is a HashMap); pass a map factory such as TreeMap::new when the order matters.

Collectors.toMap(keyFn, valueFn) throws IllegalStateException on the first duplicate key — add a third argument, a merge function, to say what happens when two elements share one.

1import java.util.*;2import java.util.stream.*;3 4public class Solution {5    record Sale(String region, String rep, int amount) {}6 7    public static List<String> describe() {8        List<Sale> sales = List.of(9            new Sale("north", "ana", 120), new Sale("south", "bo", 80),10            new Sale("north", "cy", 40), new Sale("south", "bo", 30));11 12        Map<String, Integer> totals = sales.stream().collect(13            Collectors.groupingBy(Sale::region, TreeMap::new, Collectors.summingInt(Sale::amount)));14 15        Map<String, List<String>> reps = sales.stream().collect(16            Collectors.groupingBy(Sale::region, TreeMap::new,17                Collectors.mapping(Sale::rep, Collectors.toList())));18 19        List<String> out = new ArrayList<>();20        out.add("totals " + totals);21        out.add("reps " + reps);22        try {23            sales.stream().collect(Collectors.toMap(Sale::rep, Sale::amount));24        } catch (IllegalStateException e) {25            out.add("toMap: " + e.getMessage());26        }27        Map<String, Integer> merged = sales.stream().collect(28            Collectors.toMap(Sale::rep, Sale::amount, Integer::sum, TreeMap::new));29        out.add("merged " + merged);30        return out;31    }32}

Comparators

Comparator.comparing(Person::age).thenComparing(Person::name) sorts by age, then name. .reversed() reverses the whole chain built so far, so comparing(a).thenComparing(b).reversed() reverses both keys; to reverse only one key, pass a reversed comparator for that key: thenComparing(Person::name, Comparator.reverseOrder()).

Common mistakes

• Using peek or map for side effects and expecting them to run without a terminal operation — nothing runs at all.
• Reusing a stream stored in a variable; the second terminal operation throws.
• toMap on data with repeated keys and no merge function.
• Adding to an outside ArrayList from inside forEach on a parallel stream — a data race. Collect instead.

What interviewers ask

• What is the difference between intermediate and terminal operations? Intermediate ones are lazy and return a stream; a terminal one triggers the processing and produces a result or side effect.
• Why must captured variables be effectively final? The lambda copies the value and may run later or elsewhere; reassignment would make the captured value ambiguous.
• map versus flatMap? map turns each element into one element; turns each into a stream and concatenates them.