How short circuit work in Java streams

Understand how limit() short-circuits and how a stream pipeline executes lazily and element-by-element.

---

Example Code

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

List<String> result = names.stream()
    .filter(name -> {
        System.out.println("Filtering: " + name);
        return name.length() > 3;
    })
    .map(name -> {
        System.out.println("Mapping: " + name);
        return name.toUpperCase();
    })
    .limit(2)
    .collect(Collectors.toList());

System.out.println("Result: " + result);

---

What Will Happen?

Even though there are 5 names, only the minimum number of elements needed to satisfy limit(2) will be processed.

---

Expected Output

Filtering: Alice
Mapping: Alice
Filtering: Bob
Filtering: Charlie
Mapping: Charlie
Result: [ALICE, CHARLIE]

---

Step-by-Step Explanation

Let’s understand this by simulating how the stream pipeline works.

Stream pipeline:

Source → filter → map → limit → collect

Java Streams work by pulling data through this pipeline one element at a time.

---

Iteration 1:

• Alice is passed into filter → passes (length > 3)
• Alice is passed to map() → becomes ALICE
• Collected in result list
  1 of 2 done

---

Iteration 2:

• Bob is passed into filter → fails (length <= 3)
• Not passed to map or limit
• Skipped

---

Iteration 3:

• Charlie passes filter → becomes CHARLIE
• Collected
  2 of 2 done

---

Iteration 4 and 5:

Skipped entirely
Why? Because limit(2) has already been fulfilled — it’s a short-circuiting terminal step.

---

So How Does limit() Short-Circuit?

Internally:

• limit(n) wraps the downstream Sink (collector)
• It counts how many elements have been passed downstream
• Once the limit is reached, it stops requesting more elements from upstream

It’s like: “I’ve got 2 items, I’m done. Stop pulling more!”

---

Why This Matters

• Efficiency: Even though the source has 5 items, only 3 elements were fully evaluated, and 2 were mapped.
• You save CPU cycles and memory
• It’s especially useful with large datasets, infinite streams, or expensive filters/mappings