Java Stream API

Lesson 35

Stream API processes collections functionally. Filter, map, sort, reduce — all with less code.

Java Track

Save progress as you learn.

61 lessons

Lesson content

Stream API processes collections without storing data.

Key Terms

Stream: Sequence of elements for functional operations.
Intermediate Operation: Transforms stream, returns stream.
Terminal Operation: Produces final result.
Pipeline: Chain of stream operations.

Stream Pipeline

Collection → Stream → Intermediate Operations → Terminal Operation → Result

Example 1: Filter

import java.util.Arrays;
import java.util.List;

public class FilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 10, 15, 20, 25);

        numbers.stream()
               .filter(n -> n > 10)
               .forEach(System.out::println);
    }
}

15
20
25

Example 2: Map

import java.util.Arrays;
import java.util.List;

public class MapExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("java", "stream", "api");

        names.stream()
             .map(String::toUpperCase)
             .forEach(System.out::println);
    }
}

JAVA
STREAM
API

Example 3: Sort

import java.util.Arrays;
import java.util.List;

public class SortExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(30, 10, 20, 50, 40);

        numbers.stream()
               .sorted()
               .forEach(System.out::println);
    }
}

Example 4: Reduce

import java.util.Arrays;
import java.util.List;

public class ReduceExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        int sum = numbers.stream()
                         .reduce(0, Integer::sum);

        System.out.println("Sum = " + sum);
    }
}

Sum = 15

Intermediate Operations

filter() — Keep matching elements
map() — Transform each element
sorted() — Sort elements
distinct() — Remove duplicates
limit() — Cap element count

Terminal Operations

forEach() — Process each element
collect() — Gather into collection
count() — Count elements
reduce() — Combine into one result
findFirst() — Get first element

FAQ

1. What is Stream API?

Java 8 feature for functional collection processing.

2. Stream vs Collection?

Collection stores. Stream processes.

3. Intermediate vs Terminal?

Intermediate returns stream. Terminal produces result.

Stream API introduced in Java 8.

Streams don't store data.

Intermediate ops are lazy.

Terminal ops trigger execution.

filter, map, sorted are intermediate.

forEach, collect, reduce are terminal.

Streams can't be reused after terminal.

Where Java is used

Java in real-world development

filter()

Keeps elements matching condition. filter(n -> n > 10)

map()

Transforms each element. map(String::toUpperCase)

sorted()

Natural order sort. sorted() or sorted(comparator)

reduce()

Combines elements into one. reduce(0, Integer::sum)

Intermediate vs Terminal

Intermediate returns stream. Terminal triggers and ends pipeline.

Best Practice

Keep operations stateless. Use method references. Careful with parallel streams.

Prev: Lambda Expressions Back to hub