Stream API

The Stream API is one of the most powerful features introduced in Java 8. It allows developers to process data in a clean, efficient, and functional way.

If lambda expressions made Java code concise, the Stream API makes data processing more elegant and readable.

What is Stream API?

The Stream API in Java is used to process collections of data (like List, Set, etc.) in a functional programming style.

In simple words: A stream is a sequence of elements that supports operations like filtering, mapping, sorting, and collecting data.

It helps you write less code and perform complex data operations easily without using traditional loops.

Basic Example of Stream API

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

numbers.stream()
       .filter(n -> n % 2 == 0)
       .forEach(System.out::println);

Output:

2
4

here,

• stream() → converts the collection into a stream
• filter() → selects only even numbers
• forEach() → processes and prints each element

Why Use Stream API?

Before Java 8, processing collections required:

• Loops (for, while)
• Complex logic
• More lines of code

Stream API simplifies this by:

• Reducing code
• Improving readability
• Supporting functional programming
• Enabling parallel processing

How Stream Works

A stream works in three main steps:

1. Source: The data source from where the stream is created.

Example: Collection like List, Set, etc.

2. Intermediate Operations: Used to transform or filter data. These operations are lazy and can be chained.

Examples: filter(), map(), sorted()

3. Terminal Operation: Produces the final result or output. Without this, the stream will not execute.

Examples: forEach(), collect(), count()

Stream Flow

Collection → stream() → filter/map/sorted → terminal → result

Simple flow: Data → Process → Result

👉 This flow shows how data moves step-by-step in the Stream API.

Key Features of Stream API

• Does not store data – Streams do not hold elements; they only process data from a source.
• Works on collections – Mainly used with collections like List, Set, and Map.
• Supports functional programming – Works seamlessly with lambda expressions.
• Processes data lazily – Operations are executed only when needed (improves performance).
• Can be parallel – Supports parallel processing to improve performance on large data sets.

Types of Stream Operations

Stream API operations are mainly divided into two types:

1. Intermediate Operations

These operations transform the stream and return another stream. They are lazy, meaning they do not execute until a terminal operation is called.

Common intermediate operations:

• filter() → selects elements based on a condition
• map() → transforms each element
• sorted() → sorts elements (natural or custom order)
• distinct() → removes duplicate elements
• limit() → limits the number of elements
• flatMap() → flattens nested structures into a single stream

Example:

numbers.stream()
       .filter(n -> n > 2)
       .map(n -> n * 2);

👉 This example filters numbers greater than 2 and then multiplies them by 2.

flatMap()

Used to flatten nested structures.

List<List<Integer>> list = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4)
);

list.stream()
    .flatMap(l -> l.stream())
    .forEach(System.out::println);

Output: 1 2 3 4

2. Terminal Operations

These operations produce the final result and trigger the execution of the stream.

Common terminal operations:

• forEach() → iterates over elements
• collect() → converts stream into a collection
• count() → counts elements
• findFirst() → gets the first element
• reduce() → combines values

Example:

List<Integer> result = numbers.stream()
    .filter(n -> n > 2)
    .collect(Collectors.toList());

👉 This example filters numbers greater than 2 and collects them into a list.

Common Stream Methods with Examples

Here are some commonly used Stream API methods in Java with simple examples:

1. filter()

Used to select elements based on a condition.

numbers.stream()
       .filter(n -> n % 2 == 0)
       .forEach(System.out::println);

👉 This example prints only even numbers from the list.

2. map()

Used to transform each element in the stream.

numbers.stream()
       .map(n -> n * n)
       .forEach(System.out::println);

👉 This example converts each number into its square.

3. sorted()

Used to sort elements in natural order.

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

👉 This example sorts the numbers in ascending order.

4. collect()

Used to convert stream into a collection like List.

List<Integer> list = numbers.stream()
    .filter(n -> n > 2)
    .collect(Collectors.toList());

👉 This example filters numbers greater than 2 and stores them in a list.

5. reduce()

Used to combine elements into a single result.

int sum = numbers.stream()
    .reduce(0, (a, b) -> a + b);

👉 This example calculates the sum of all numbers.

Stream API with Strings

List<String> names = Arrays.asList("Ram", "Shyam", "Amit");

names.stream()
     .filter(name -> name.startsWith("A"))
     .forEach(System.out::println);

👉 This example filters and prints names that start with "A".

• Useful for string filtering and searching
• Makes code simple and readable

Parallel Streams

Stream API also supports parallel processing, which allows tasks to run on multiple threads.

numbers.parallelStream()
       .forEach(System.out::println);

👉 This example processes elements in parallel instead of sequentially.

• Faster for large datasets
• Utilizes multi-core CPU for better performance

👉 Important Notes on Parallel Streams

• Not always faster (depends on data size)
• Order may not be maintained
• Be careful with shared data (thread safety issues)

Advantages of Stream API

• Less code – Reduces the need for loops and boilerplate code.
• Better readability – Code is clean, simple, and easy to understand.
• Easy data processing – Makes filtering, mapping, and sorting very simple.
• Supports parallel execution – Can process large data faster using multiple threads.
• Functional programming style – Works well with lambda expressions for modern Java coding.

Limitations of Stream API

• Not suitable for very small or simple tasks, where loops may be easier.
• Debugging can be difficult, especially with chained operations.
• Cannot reuse a stream once it is consumed (you need to create a new stream).

When to Use Stream API

Use Stream API when:

• Working with collections like List, Set, or Map.
• Performing data transformations (filtering, mapping, sorting).
• Writing clean, concise, and readable code.
• Handling large datasets, especially with parallel processing.

When NOT to Use Stream API

Avoid using Stream API when:

• Logic is very simple, where loops are easier to understand.
• Performance overhead matters, especially for small datasets.
• Debugging is critical, as streams can be harder to trace.

Real-World Use Cases

Stream API is widely used in real-world applications for efficient data handling:

• Data filtering (e.g., users, products, records).
• Data transformation (convert or modify data).
• Aggregation (sum, count, average, etc.).
• Sorting and searching operations.
• Backend processing in modern applications.

Conclusion

The Stream API in Java is a powerful tool for handling data in a modern, clean, and efficient way.

It works perfectly with:

• Lambda expressions
• Functional interfaces

By using Stream API, you can write less code, improve readability, and process data more effectively in real-world Java applications.