Streams & Functional Java Terminology — Interview Reference

Why this matters in interviews

Stream questions reveal whether you understand execution semantics, not just syntax. Interviewers at senior level will push past "chain filter-map-collect" to ask why sorted() breaks lazy evaluation, when flatMap is required over map, and why parallel streams can silently corrupt data. Knowing the precise vocabulary lets you answer confidently and concisely.

Concept

Core Pipeline Terms

---

Execution Model

---

Transformation Operations

---

Terminal Operations

---

Collectors

---

Optional

---

Parallel Streams

---

Functional Interfaces

Key rules / gotchas

• No terminal op = silent no-op: the entire pipeline is never executed; no warning is emitted.
• orElse is eager: the default value expression is always evaluated even when the Optional contains a value — use orElseGet with a Supplier for expensive defaults.
• flatMap vs map: if your map function returns Stream<T> or Optional<T>, you almost certainly want flatMap — otherwise you get a stream of streams or a stream of optionals.
• sorted() is an O(n) memory barrier: it must buffer all upstream elements before emitting the first output element. Always place filter() and limit() before sorted().
• distinct() requires correct equals/hashCode: it is backed by a HashSet; objects that don't override both will not deduplicate correctly.
• Stream is single-use: once a terminal op fires, any further call on the same Stream instance throws IllegalStateException.
• toMap throws on duplicate keys: always provide a merge function (existing, replacement) -> existing when duplicates are possible.
• Collectors.toList() returns mutable; .toList() (Java 16+) returns unmodifiable: mixing them up causes UnsupportedOperationException at runtime.
• Parallel + shared mutable state = data race: adding to an ArrayList from multiple threads inside forEach silently produces incorrect results.

Code example

import java.util.*;
import java.util.stream.*;
import java.util.function.*;

public class JavaLabRunner {
    record Person(String name, String dept, int salary) {}

    public static void main(String[] args) {
        List<Person> people = List.of(
            new Person("Alice", "Eng", 90000),
            new Person("Bob",   "Eng", 85000),
            new Person("Carol", "HR",  70000),
            new Person("Dave",  "HR",  72000)
        );

        // map vs flatMap
        List<String> upper = people.stream()
            .map(p -> p.name().toUpperCase())       // 1-to-1
            .collect(Collectors.toList());
        System.out.println("map: " + upper);

        List<String> words = List.of("Hello World", "Java Streams");
        List<String> tokens = words.stream()
            .flatMap(s -> Arrays.stream(s.split(" "))) // 1-to-many, then flatten
            .collect(Collectors.toList());
        System.out.println("flatMap: " + tokens);

        // Stateful op: put filter before sorted
        people.stream()
            .filter(p -> p.salary() > 75000)       // reduce set first
            .sorted(Comparator.comparingInt(Person::salary))
            .map(Person::name)
            .forEach(System.out::println);

        // groupingBy + downstream
        Map<String, Double> avgByDept = people.stream()
            .collect(Collectors.groupingBy(
                Person::dept,
                Collectors.averagingInt(Person::salary)
            ));
        System.out.println("Avg salary: " + avgByDept);

        // Optional.flatMap to avoid Optional<Optional<T>>
        Optional<String> email = Optional.of("alice@example.com");
        Optional<String> domain = email
            .flatMap(e -> Optional.of(e.split("@")[1])); // function returns Optional
        System.out.println("Domain: " + domain.orElse("none"));

        // orElse (eager) vs orElseGet (lazy)
        Optional<String> empty = Optional.empty();
        String a = empty.orElse("default");          // "default" always evaluated
        String b = empty.orElseGet(() -> "lazy");    // Supplier called only when absent
        System.out.println("orElse: " + a + ", orElseGet: " + b);

        // Stream.generate (infinite) + limit (short-circuit)
        List<Double> randoms = Stream.generate(Math::random)
            .limit(5)
            .collect(Collectors.toList());
        System.out.println("5 randoms: " + randoms.size());
    }
}

Interview questions you should be able to answer

• Q: What is the difference between map and flatMap?

  map applies a 1-to-1 transformation — one input produces exactly one output element. flatMap applies a 1-to-many transformation — one input produces a Stream of zero or more outputs, which is then flattened into the main stream. Use flatMap whenever your mapping function returns a Stream or an Optional; using map in those cases gives you Stream<Stream<T>> or Stream<Optional<T>>, which requires an extra unwrap.

• Q: Why is orElse potentially problematic for expensive computations?

  orElse(expression) evaluates expression eagerly — before checking whether the Optional contains a value. If the expression is a method call with side effects or high cost (e.g., a DB query), it runs even when the value is present and the result is thrown away. orElseGet(() -> expression) wraps the expression in a Supplier that is only invoked when the Optional is empty.

• Q: Why does sorted() break the element-by-element pull model of lazy evaluation?

  sorted() is a stateful intermediate operation. It cannot emit any element until it has seen all upstream elements, because the first element in sorted order might be the last one in the source. This forces a full materialisation of all upstream elements into a buffer (O(n) memory), after which the sorted sequence is emitted. Every element before sorted() in the pipeline is fully consumed before the first element after sorted() is produced.

• Q: What happens when you call Collectors.toMap and two elements produce the same key?

  It throws java.lang.IllegalStateException: Duplicate key <value>. Fix: provide a merge function as the third argument — toMap(keyFn, valueFn, (existing, replacement) -> existing) keeps the first value, (e, r) -> r keeps the last. When building a Map where duplicates are expected, also consider groupingBy which naturally collects duplicates into a list.

• Q: What is the difference between findFirst and findAny, and when does the choice matter?

  Both return an Optional of one element that passes the filter. findFirst guarantees the first element in encounter order; findAny may return any element. On a sequential stream they behave identically. On a parallel stream, findFirst forces the runtime to track encounter order across all partitions, serialising result resolution. findAny allows the first partition to finish to win, giving better parallel throughput. Always prefer findAny in parallel pipelines when order is irrelevant.

• Q: When is it unsafe to use a parallel stream and why?

  Parallel streams are unsafe when: (1) the pipeline mutates shared mutable state — multiple threads write to the same ArrayList or counter causing data races; (2) the source is not efficiently splittable — LinkedList or Stream.iterate splits poorly; (3) operations have side effects that must happen in order. The biggest silent failure mode is writing to an unsynchronised collection inside forEach — it produces wrong results with no exception.

Further reading

• java.util.stream package summary (OpenJDK)
• Java Collectors Javadoc
• Optional Javadoc (OpenJDK)