Streams API

Advanced ~20 min read

A Stream in Java is a sequence of objects that supports various methods which can be pipelined to produce the desired result. It allows you to process data declaratively.

How Stream Works

A Stream pipeline consists of three parts:

Source: Collections, Arrays, or I/O channels.
Intermediate Operations: Transform the stream (e.g., filter, map, sorted). These are lazy!
Terminal Operation: Produces a result (e.g., forEach, collect, count).

1. Filter

Selects elements based on a condition (Predicate).

list.stream().filter(s -> s.startsWith("A"))

2. Map

Transforms each element (Function).

list.stream().map(s -> s.toUpperCase())

3. Collect

Gathers the result into a Collection.

.collect(Collectors.toList())

Full Example

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

public class StreamExample {
    public static void main(String[] args) {

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

// 1. FILTERING: Get names starting with 'A' or 'B'
        System.out.println("--- Filtered Names ---");
        names.stream()
                .filter(name -> name.startsWith("A") || name.startsWith("B"))
                .forEach(System.out::println);

// 2. MAPPING: Convert all to Uppercase
        System.out.println("\n--- Uppercase Names ---");
        List<String> uppercaseNames = names.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println(uppercaseNames);

// 3. REDUCING (Counting)
        long count = names.stream()
                .filter(name -> name.length() > 4)
                .count();
        System.out.println("\nNumber of names with > 4 letters: " + count);

// 4. SORTING
        System.out.println("\n--- Sorted (Reverse) ---");
        names.stream()
                .sorted((a, b) -> b.compareTo(a)) // Custom Lambda Comparator
                .forEach(System.out::println);
    }
}

Output

Click Run to execute your code

Summary

Streams make code readable and concise.
They do not store data; they process it.
Intermediate operations are lazy (nothing happens until a terminal op is called).

Previous Lambda Expressions

Next Threading Basics →