What is the difference between Stream and Collection in Java?

The Interview Question

Short Answer

A Collection (e.g., List, Set, Map) is an in-memory data structure that holds elements. You can iterate it many times, add or remove elements, and query its size at any point.

A Stream is a sequence of elements that supports aggregate operations. It does not store data — it computes results from a source (often a Collection) on demand. Streams are lazy (computation happens only at the terminal operation), single-use (consumed after one terminal call), and can be parallel with no extra code changes.

Detailed Explanation

1. Data Storage vs. Computation Pipeline

Collections are designed to store and organize data. They live fully in memory. Streams are designed to describe computations to be performed on data. A stream holds no elements itself — it wraps a source and a chain of operations.

2. Lazy vs. Eager Evaluation

Collections are eager: when you add an element, it is immediately stored. Streams are lazy: intermediate operations such as filter(), map(), and sorted() build up a recipe but do nothing until a terminal operation is called.

3. Internal vs. External Iteration

External iteration (Collections): The developer controls the loop — a for loop or iterator.

Internal iteration (Streams): The Stream API controls the traversal. You declare what to do (predicate, mapping function) and the API decides how to do it, including whether to run in parallel.

4. Single-Use vs. Reusable

A Collection can be traversed any number of times. A Stream is consumed exactly once. Calling a second terminal operation on a used stream throws IllegalStateException: stream has already been operated upon or closed.

5. Intermediate vs. Terminal Operations

Intermediate operations return a new Stream and are lazy:

• filter(Predicate) — keeps elements matching the condition
• map(Function) — transforms each element
• flatMap(Function) — flattens nested streams
• sorted(), distinct(), limit(n), skip(n), peek(Consumer)

Terminal operations trigger the pipeline and produce a result:

• collect(Collector) — accumulates into a collection or value
• forEach(Consumer) — side-effect for each element
• count(), sum(), min(), max(), average()
• findFirst(), findAny(), anyMatch(), allMatch(), noneMatch()
• reduce(BinaryOperator)

6. Parallel Streams

Any stream can be switched to parallel processing with a single call to .parallel() or by using Collection.parallelStream(). The Fork/Join framework splits the work across multiple CPU cores automatically.

Code Example

import java.util.List;
import java.util.stream.Collectors;

public class StreamVsCollection {

    public static void main(String[] args) {

        // ── Collection: stored, reusable, external iteration ──────────────
        List<String> names = List.of("Alice", "Bob", "Charlie", "Dave", "Eve");

        // Iterate multiple times — fine for a Collection
        System.out.println("All names:");
        for (String name : names) {
            System.out.println("  " + name);
        }
        System.out.println("Size: " + names.size()); // available any time

        // ── Stream: lazy pipeline, single-use, internal iteration ─────────
        List<String> result = names.stream()           // source
            .filter(n -> n.length() > 3)               // intermediate (lazy)
            .map(String::toUpperCase)                   // intermediate (lazy)
            .sorted()                                   // intermediate (lazy)
            .collect(Collectors.toList());              // terminal — triggers pipeline

        System.out.println("Filtered & sorted: " + result);
        // Output: [ALICE, CHARLIE, DAVE]

        // ── Short-circuit: stops at first match ───────────────────────────
        names.stream()
            .filter(n -> n.startsWith("C"))
            .findFirst()                                // terminal — short circuits
            .ifPresent(n -> System.out.println("First C name: " + n));

        // ── Parallel stream ───────────────────────────────────────────────
        long count = names.parallelStream()
            .filter(n -> n.length() > 3)
            .count();
        System.out.println("Names longer than 3 chars: " + count);

        // ── Stream is single-use ──────────────────────────────────────────
        var stream = names.stream().filter(n -> n.length() > 3);
        stream.count();   // OK — consumes the stream
        // stream.count(); // would throw IllegalStateException

        // ── Infinite stream (impossible with a Collection) ────────────────
        List<Integer> firstTenEvens = java.util.stream.Stream.iterate(0, n -> n + 2)
            .limit(10)
            .collect(Collectors.toList());
        System.out.println("First 10 evens: " + firstTenEvens);
    }
}

When to Use

Use a Collection when:

• You need to store elements and access them repeatedly.
• You need random access (e.g., list.get(index)).
• You need to modify the data structure (add, remove, update elements).
• You need to know the size upfront.

Use a Stream when:

• You are transforming, filtering, or aggregating data.
• You want a declarative, readable pipeline instead of imperative loops.
• You want easy parallelism for large datasets.
• You are working with infinite or very large sequences (e.g., Stream.generate(), I/O lines).

Why This Question Matters in Interviews

This question tests whether a candidate understands Java 8's functional programming model. Interviewers want to see:

• You know that lazy evaluation enables optimization and short-circuiting.
• You understand the single-use nature of streams and can explain the exception it throws.
• You can distinguish intermediate from terminal operations — this is critical for debugging stream pipelines.
• You know when parallel streams help and when they hurt performance.

A strong answer compares the two across 4–5 dimensions (storage, evaluation, iteration style, reusability, parallelism) and supports the explanation with a concrete code example.

Common Pitfalls

• Reusing a stream — storing a stream in a variable and calling two terminal operations causes an IllegalStateException at runtime.
• Forgetting the terminal operation — a pipeline with only intermediate operations never executes. This is a silent bug that produces no output.
• Mutating the source during streaming — modifying the backing collection while a stream is active leads to ConcurrentModificationException.
• Overusing parallel streams — parallel streams have thread-pool overhead and require thread-safe operations. They are rarely beneficial for collections under a few thousand elements.
• Confusing peek() with forEach() — peek() is intermediate and lazy; it should only be used for debugging, not for side-effects in production code.

Conclusion

Collections and Streams serve complementary roles in Java. Collections are the primary data structures for storing and organizing elements in memory. Streams are a powerful API for expressing data-processing pipelines in a declarative, lazy, and optionally parallel manner. Understanding when to use each — and the mechanics behind lazy evaluation, single-use consumption, and internal iteration — is essential for writing modern, idiomatic Java code and for answering this common interview question confidently.