Java Streams, Decoded

A stream is a conveyor belt, not a box.

A List is a box of items sitting on a shelf. A Stream is a conveyor belt you put those items on. You bolt little machines along the belt — one keeps only the items you want, one reshapes each item, one bundles the result at the end. The belt does nothing until you attach the final machine that catches the output.

Three reasons this matters for you:

1. It reads like a sentence.  "Take the numbers, keep the even ones, square them, add them up." That's literally the code.
2. It's lazy.  Nothing runs until you ask for a result — so Java can fuse the steps and skip unnecessary work.
3. It kills boilerplate.  The transformations you do constantly in DSA — list→set, array→sum, group-by, dedupe, sort-by-key — collapse to one fluent line.

Every stream has three parts.

Source, then zero-or-more intermediate operations, then exactly one terminal operation. Learn this skeleton and every stream you ever read becomes legible.

List<Integer> nums = List.of(1, 2, 3, 4, 5, 6);

int result = nums.stream()            // SOURCE: put items on the belt
    .filter(n -> n % 2 == 0)         // INTERMEDIATE: keep evens  -> 2,4,6
    .map(n -> n * n)                  // INTERMEDIATE: square them  -> 4,16,36
    .reduce(0, Integer::sum);       // TERMINAL: add them up      -> 56

// result == 56

You already know this. Here's the translation.

Take the things you do reflexively in Python and JavaScript and see the exact Java equivalent. The verbs are nearly identical — the ceremony is the only difference.

Map: transform every element

Filter: keep only what passes

Reduce: fold into a single value

The whole pipeline, side by side

# Python
result = [n * 2 for n in nums if n % 2 == 0]

// JavaScript
const result = nums.filter(n => n % 2 === 0).map(n => n * 2);

// Java
var result = nums.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * 2)
    .toList();

The intermediate operations worth memorizing.

These return a new stream, so they chain. None of them run until a terminal op fires.

And the terminal operations that finish the job

flatMap — the one that trips everyone up

map turns each element into one thing. flatMap turns each element into a stream of things, then flattens them all into one stream. Perfect for "list of lists → one list," a constant in matrix and graph problems.

int[][] grid = {{1, 2}, {3, 4}, {5, 6}};

List<Integer> flat = Arrays.stream(grid)        // Stream<int[]>
    .flatMap(Arrays::stream)               // IntStream per row, flattened
    .boxed()
    .toList();
// [1, 2, 3, 4, 5, 6]

How you step off the belt.

collect() is the terminal op you'll use most. Pair it with a Collectors recipe to shape the output — list, set, map, joined string, or grouped buckets.

// 1. To a List / Set
.collect(Collectors.toList())
.collect(Collectors.toSet())

// 2. Join strings:  ["a","b","c"] -> "a, b, c"
.collect(Collectors.joining(", "))

// 3. To a Map:  word -> its length
.collect(Collectors.toMap(w -> w, String::length))

// 4. groupingBy:  the Python defaultdict(list) move
.collect(Collectors.groupingBy(w -> w.length()))
// {1=[a], 3=[cat, dog], 5=[hello]}

// 5. counting frequency:  the Counter() move
.collect(Collectors.groupingBy(c -> c, Collectors.counting()))
// {'a'=2, 'b'=1, 'c'=3}

Streams that earn their keep in interviews.

Concrete, copy-able patterns for the transformations that come up over and over. These are the moments where a stream beats a hand-written loop on readability.

Array ↔ List ↔ primitives

// int[] -> List<Integer>
List<Integer> list = Arrays.stream(arr).boxed().toList();

// List<Integer> -> int[]
int[] back = list.stream().mapToInt(Integer::intValue).toArray();

// sum / max / average of an int[]
int total = Arrays.stream(arr).sum();
OptionalInt max = Arrays.stream(arr).max();
double avg = Arrays.stream(arr).average().orElse(0);

Frequency map (the Counter pattern)

String s = "banana";
Map<Character, Long> freq = s.chars()
    .mapToObj(c -> (char) c)
    .collect(Collectors.groupingBy(c -> c, Collectors.counting()));
// {a=3, b=1, n=2}

Sort by a custom key (and reversed)

List<String> words = List.of("bb", "a", "ccc");

// by length, ascending
words.stream().sorted(Comparator.comparingInt(String::length)).toList();
// [a, bb, ccc]

// by length, descending
words.stream().sorted(Comparator.comparingInt(String::length).reversed()).toList();
// [ccc, bb, a]

Generate ranges (no manual for-loop)

// 0..n  ->  IntStream.range is exclusive of the end
int[] ids = IntStream.range(0, 5).toArray();        // [0,1,2,3,4]

// sum of 1..100
int sum = IntStream.rangeClosed(1, 100).sum();      // 5050

Top K frequent (a classic, end to end)

int[] nums = {1, 1, 1, 2, 2, 3};
int k = 2;

List<Integer> topK = Arrays.stream(nums).boxed()
    .collect(Collectors.groupingBy(n -> n, Collectors.counting()))
    .entrySet().stream()
    .sorted(Map.Entry.<Integer,Long>comparingByValue().reversed())
    .limit(k)
    .map(Map.Entry::getKey)
    .toList();
// [1, 2]

What bites people (and what interviewers probe).

Build the muscle. Try before you peek.

Write each as a single stream pipeline. Solutions are hidden — struggle first, that's where the learning lives.

int ans = nums.stream()
    .filter(n -> n % 2 == 0)
    .mapToInt(n -> n * n)
    .sum();

List<String> ans = names.stream()
    .map(String::toUpperCase)
    .sorted()
    .toList();

Map<Character, Long> ans = s.chars()
    .mapToObj(c -> (char) c)
    .collect(Collectors.groupingBy(
        c -> c, Collectors.counting()));

Map<Character, List<String>> ans = words.stream()
    .collect(Collectors.groupingBy(w -> w.charAt(0)));

List<List<String>> ans = new ArrayList<>(
  words.stream()
    .collect(Collectors.groupingBy(w -> {
    char[] c = w.toCharArray();
    Arrays.sort(c);
    return new String(c);   // "eat","tea" -> "aet"
    }))
    .values());

List<Integer> ans = matrix.stream()
    .flatMap(List::stream)   // flatten rows into one stream
    .distinct()
    .sorted()
    .toList();

Quick gut-check.

Click an answer — you'll get instant feedback. No scrolling for solutions.

Print this. Pin it. Recall it.

How to explain a stream out loud.

Interviewers don't just want working code — they want to hear that you understand the model. Here's a 30-second answer you can adapt.

Three follow-ups they love to ask

"Lazy vs eager?" — Intermediate ops are lazy (build the recipe); the terminal op is eager (runs it). Nothing happens without a terminal op.
"Can you reuse a stream?" — No. It's consumed after one terminal op; create a fresh one.
"When would you not use a stream?" — Tight performance-critical loops, or when you need to mutate indices / break early in a complex way — a plain loop is clearer and sometimes faster.