Java streams and collectors quiz (10 questions)

1. Which statement about intermediate operations such as map and filter is correct?

Answer summary

They are lazy and usually run only when a terminal operation starts the pipeline — Intermediate operations are lazy and usually do not execute until a terminal operation triggers the pipeline.

Stream pipelines are assembled first and evaluated later, which allows operation fusion and short-circuit behavior. This is a common interview point because it affects both performance reasoning and debugging expectations.

Interview tip: A useful follow-up is to explain why peek often appears to do nothing until a terminal operation is present.

2. You have a Stream<String> and want one List<String> result. Which terminal operation is the clearest default choice in modern Java?

Answer summary

collect(Collectors.toList()) — collect(Collectors.toList()) is the clearest default terminal operation for gathering stream elements into a list across common Java versions.

collect is a terminal operation that consumes the stream and accumulates results. The other listed methods are intermediate operations and do not finish the pipeline by themselves.

List<String> names = users.stream()
  .map(User::name)
  .collect(Collectors.toList());

Interview tip: Depending on Java version, interviewers may also ask about Stream.toList and how its mutability characteristics differ.

3. Which collector is the best fit when you want Map<Department, List<Employee>> from a stream of employees?

Answer summary

groupingBy(Employee::department) — groupingBy(Employee::department) is the best fit for collecting elements into lists grouped by department.

groupingBy classifies each element by a key extractor and gathers matching elements together. partitioningBy is only for boolean splits. joining is for strings, and counting produces totals rather than grouped lists.

Interview tip: A common follow-up is how to add a downstream collector such as counting or mapping to transform each group.

4. You need to split candidates into pass and fail buckets based on a predicate. Which collector is most direct?

Answer summary

partitioningBy(Candidate::passed) — partitioningBy is the most direct collector for a boolean split into two buckets.

partitioningBy is specialized for true or false classification and returns a two-key map. groupingBy can also work on booleans, but partitioningBy communicates the intent more clearly.

Interview tip: Strong answers mention that the returned map includes both boolean keys even if one side is empty, depending on the collector behavior.

5. Why are side effects inside stream operations often discouraged?

Answer summary

Side effects make pipelines harder to reason about and can become unsafe with parallel execution — Side effects are discouraged because they reduce readability and can break assumptions, especially once the stream is parallelized.

Streams are easiest to understand when each stage transforms data without mutating external state. Hidden mutations can introduce ordering issues, race conditions, and surprising behavior if the pipeline runs in parallel.

Interview tip: Interviewers often ask for a concrete bad example, such as mutating a shared ArrayList from forEach on a parallel stream.

6. Which statement about findFirst and findAny is most accurate?

Answer summary

findAny may return any matching element and can be more flexible for parallel execution — findAny may return any matching element and can be more flexible for parallel execution, while findFirst respects encounter order when relevant.

On ordered streams, findFirst preserves the first encountered element, which can constrain optimization. findAny allows the implementation more freedom and is often discussed in parallel stream interviews.

Interview tip: A strong answer connects this to the broader concept of encounter order and when it matters for correctness.

7. A method returns Optional<User> from stream().filter(...).findFirst(). What interview point matters most next?

Answer summary

Optional should usually be handled explicitly rather than calling get blindly — The important point is to handle Optional explicitly instead of calling get without checking.

Optional communicates possible absence and encourages callers to choose a clear branch such as orElse, orElseThrow, or map. Blind get is a common anti-pattern because it recreates the same failure mode as unchecked null assumptions.

Interview tip: Follow-ups often compare Optional in return types versus fields and serialization-heavy DTOs.

8. Which statement about a Stream instance is correct?

Answer summary

It is consumed once and should not be reused after a terminal operation — A Stream is consumed once and should not be reused after a terminal operation.

Streams model a pipeline of traversal and computation, not a reusable container. Reusing an already consumed stream leads to IllegalStateException in common cases. If you need multiple traversals, create a fresh stream from the source.

Interview tip: This question often tests whether the candidate treats streams as data structures instead of one-shot processing pipelines.

9. When is parallelStream a poor default choice?

Answer summary

When the work is tiny, order-sensitive, or interacts with shared mutable state — parallelStream is a poor default when the work is too small, heavily order-dependent, or relies on shared mutable state.

Parallelism adds coordination overhead and can make bugs harder to reason about. It helps only when the workload is large enough, sufficiently independent, and measured to benefit on the actual runtime environment.

Interview tip: Strong answers mention benchmarking and the shared ForkJoinPool instead of treating parallelStream as a free speed-up switch.

10. Which collector is the best fit when you need one comma-separated String from a stream of names?

Answer summary

joining(\", \") — joining(\", \") is the right collector for concatenating stream elements into one delimited String.

Collectors.joining is built for string concatenation with optional delimiter, prefix, and suffix. The other collectors produce grouped or set-based results rather than one combined String.

String csv = names.stream()
  .collect(Collectors.joining(", "));

Interview tip: A common follow-up is whether the candidate knows when joining large strings through stream code is clearer than a manual StringBuilder loop.