Stream in Java

Java Streams have become an essential part of modern Java programming. Introduced in Java 8, Streams provide a powerful way to process sequences of elements in a functional style. They simplify operations on collections, arrays, or data sources, enabling cleaner and more readable code. This guide covers everything you need to know about Stream in Java, from basics to advanced use cases.

What is a Stream in Java?

A Stream in Java is a sequence of elements supporting functional-style operations on data. Unlike collections, streams do not store elements; instead, they compute results on demand.

• No storage: Streams do not hold data; they operate on data from sources like collections, arrays, or I/O channels.
• Functional operations: Supports map, filter, reduce, and other operations.
• Lazy evaluation: Intermediate operations are executed only when a terminal operation is invoked.
• Parallel processing: Easily process data in parallel to improve performance.

Stream in Java: Complete Guide with Examples and Use Cases

Java Streams, introduced in Java 8, provide a modern way to process sequences of elements using a functional approach. Streams make working with collections, arrays, and other data sources concise and readable. This guide explains Java Streams for beginners and intermediate learners with practical examples and real-world use cases.

What is a Stream in Java?

A Stream in Java is a sequence of elements that supports functional-style operations. Unlike collections, streams do not store data; they process it on demand.

• No storage: Streams do not hold elements themselves.
• Functional operations: Use map(), filter(), reduce(), etc.
• Lazy evaluation: Operations are executed only when a terminal operation is called.
• Parallel processing: Easily process large datasets concurrently.

Creating Streams in Java

From a Collection

📄

import java.util.*;
import java.util.stream.*;

List names = Arrays.asList("Alice", "Bob", "Charlie");
Stream nameStream = names.stream();
nameStream.forEach(System.out::println);
    

From an Array

📄

String[] fruits = {"Apple", "Banana", "Cherry"};
Stream fruitStream = Arrays.stream(fruits);
fruitStream.forEach(System.out::println);
    

Using Stream.of()

📄

Stream numbers = Stream.of(1, 2, 3, 4, 5);
numbers.forEach(System.out::println);
    

Common Stream Operations

1. Filtering Data

📄

List numbers = Arrays.asList(1, 2, 3, 4, 5);
List evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());
System.out.println(evenNumbers);
    

2. Mapping Data

📄

List names = Arrays.asList("Alice", "Bob");
List nameLengths = names.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());
System.out.println(nameLengths);
    

3. Reducing Data

📄

List numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .reduce(0, Integer::sum);
System.out.println("Sum: " + sum);
    

4. Sorting Data

📄

List names = Arrays.asList("Charlie", "Alice", "Bob");
List sortedNames = names.stream()
                                .sorted()
                                .collect(Collectors.toList());
System.out.println(sortedNames);
    

5. Removing Duplicates

📄

List numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
List uniqueNumbers = numbers.stream()
                                     .distinct()
                                     .collect(Collectors.toList());
System.out.println(uniqueNumbers);
    

Parallel Streams in Java

📄

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
int sum = numbers.parallelStream()
                 .mapToInt(Integer::intValue)
                 .sum();
System.out.println("Parallel Sum: " + sum);
    

Note: Use parallel streams cautiously. They are most beneficial for CPU-intensive operations and large datasets.

Real-World Use Case: Filtering Employees

📄

class Employee {
    String name;
    int age;

    Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

List employees = Arrays.asList(
    new Employee("Alice", 30),
    new Employee("Bob", 22),
    new Employee("Charlie", 28)
);

List filteredEmployees = employees.stream()
    .filter(emp -> emp.age > 25)
    .collect(Collectors.toList());

filteredEmployees.forEach(emp -> System.out.println(emp.name));
    

Advantages of Using Stream in Java

• Cleaner, more readable code with fewer loops
• Functional-style operations for easier transformations
• Efficient processing of large datasets
• Parallel execution support for multi-core processing

Core Components of Java Streams

Intermediate Operations

These operations return a new stream and are lazy. Examples include:

filter() – filters elements based on a predicate

map() – transforms elements

distinct() – removes duplicates

sorted() – sorts elements

Terminal Operations

These operations produce a result or side effect and trigger processing of the stream. Examples include:

forEach() – performs an action for each element

collect() – gathers elements into a collection

reduce() – reduces elements to a single value

count() – counts elements

Creating a Stream in Java

From a Collection

📄

import java.util.*;
import java.util.stream.*;

public class StreamExample {
    public static void main(String[] args) {
        List names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        Stream nameStream = names.stream();
        nameStream.forEach(System.out::println);
    }
}
    

From an Array

📄

import java.util.*;
import java.util.stream.*;

public class ArrayStreamExample {
    public static void main(String[] args) {
        String[] fruits = {"Apple", "Banana", "Cherry"};

        Stream fruitStream = Arrays.stream(fruits);
        fruitStream.forEach(System.out::println);
    }
}
    

Using Stream.of()

📄

import java.util.stream.*;

public class StreamOfExample {
    public static void main(String[] args) {
        Stream numbers = Stream.of(1, 2, 3, 4, 5);
        numbers.forEach(System.out::println);
    }
}
    

Common Stream Operations with Examples

Filtering Data

📄

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());
System.out.println(evenNumbers);
    

Mapping Data

📄

List names = Arrays.asList("Alice", "Bob");
List nameLengths = names.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());
System.out.println(nameLengths);
    

Reducing Data

📄

List numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .reduce(0, (a, b) -> a + b);
System.out.println("Sum: " + sum);
    

Sorting Data

📄

List names = Arrays.asList("Charlie", "Alice", "Bob");
List sortedNames = names.stream()
                                .sorted()
                                .collect(Collectors.toList());
System.out.println(sortedNames);
    

Removing Duplicates

📄

List numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
List uniqueNumbers = numbers.stream()
                                     .distinct()
                                     .collect(Collectors.toList());
System.out.println(uniqueNumbers);
    

Real-World Use Cases of Java Streams

• Data filtering: Processing lists of users or products
• Data transformation: Converting JSON objects into domain objects
• Aggregation: Summing, averaging, or counting values in collections
• Parallel processing: Large datasets in multi-threaded environments
• File processing: Reading and filtering large files efficiently

Example: Filtering a List of Employees

📄

class Employee {
    String name;
    int age;

    Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

List employees = Arrays.asList(
    new Employee("Alice", 30),
    new Employee("Bob", 22),
    new Employee("Charlie", 28)
);

List filteredEmployees = employees.stream()
    .filter(emp -> emp.age > 25)
    .collect(Collectors.toList());

filteredEmployees.forEach(emp -> System.out.println(emp.name));
    

Parallel Streams in Java

📄

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
int sum = numbers.parallelStream()
                 .mapToInt(Integer::intValue)
                 .sum();
System.out.println("Parallel Sum: " + sum);
    

Note: Parallel streams are not always faster. Use them carefully for CPU-intensive tasks.

Summary

Streams in Java provide a modern, functional approach to handling collections and sequences of data. By using intermediate and terminal operations, developers can write more concise, readable, and efficient code. Streams are ideal for filtering, transforming, aggregating, and processing data both sequentially and in parallel. Understanding Streams is essential for any Java developer seeking to write clean and performant applications.

FAQs About Stream in Java

1. What is the difference between a Stream and a Collection in Java?

Collections store data, while Streams process data without storing it. Streams are used for functional-style operations, while collections focus on storage and retrieval.

2. Can a Stream be reused after a terminal operation?

No. Once a terminal operation is executed, the stream is consumed and cannot be reused. You must create a new stream for further operations.

3. What are intermediate operations in a Stream?

Intermediate operations return a new stream and are lazy, such as map(), filter(), and distinct(). They are executed only when a terminal operation is invoked.

4. How can I perform parallel processing with Streams?

Use parallelStream() on a collection to process elements in parallel. Example: collection.parallelStream().forEach(System.out::println);

5. When should I avoid using Streams?

Avoid Streams for simple loops with minimal processing, where overhead may outweigh benefits. Also, avoid parallel streams when thread-safety or order matters.

Conclusion

Java Streams provide a modern, functional approach to processing collections and sequences of data. By using streams, developers can write cleaner, more readable, and efficient code with operations like map, filter, reduce, and collect. Streams also support parallel processing, making it easier to handle large datasets efficiently. Understanding streams is essential for writing modern Java applications that are both performant and maintainable.