Introduction

Java is one of the most widely used programming languages in enterprise application development. Before Java 8, developers generally used loops and conditional statements to process collections such as Lists, Sets, and Maps.

Although traditional loops work perfectly fine, they can sometimes make code lengthy and difficult to maintain.

Java 8 introduced the Stream API, which provides a cleaner and more readable way to process collections using functional programming concepts.

In this article, we will understand the Java 8 Stream API from the basics and explore practical examples that can be used in real-world Java applications.

1. What is Stream API in Java 8?

The Stream API is a feature introduced in Java 8 that allows developers to process collections of data in a functional and declarative way.

It supports operations such as:

• Filtering data
• Transforming data
• Sorting elements
• Finding matching elements
• Removing duplicates
• Grouping data
• Calculating values

Important: A Stream does not store data. It processes data from a source such as a List, Set, or Array.

Basic Stream workflow

A Stream generally follows three steps:

1. Source — The collection or data source.
2. Intermediate operations — Operations such as filter(), map(), and sorted().
3. Terminal operation — Operations such as collect(), forEach(), and count().

Example workflow:

Collection → Stream → Intermediate Operations → Terminal Operation → Result

2. Why do we use Stream API?

Let’s understand the advantages.

• Readable code: Reduces unnecessary loops and conditions.
• Less boilerplate: Makes collection processing simpler.
• Functional programming: Supports lambda expressions and method references.
• Parallel processing: Supports parallelStream() for certain workloads.
• Easy data transformation: Allows filtering, mapping, and sorting in a pipeline.

3. Creating a Stream

There are different ways to create a Stream in Java 8.

Example 1: Creating a Stream from a List

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

public class StreamExample {

    public static void main(String[] args) {

        // Create a list of numbers
        List<Integer> numbers = Arrays.asList(10, 20, 30, 40, 50);

        // Convert the list into a stream
        numbers.stream()

               // Print each element
               .forEach(System.out::println);
    }
}

Output:

10
20
30
40
50

Here, stream() converts the List into a Stream, and forEach() processes each element.

4. Important Stream API Operations

Let’s explore the most commonly used Stream operations.

Example 2: filter()

The filter() method is used to select elements based on a given condition.

Scenario: Find all employees whose salary is greater than 50,000.

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

public class FilterExample {

    public static void main(String[] args) {

        // Create a list of employee salaries
        List<Integer> salaries = Arrays.asList(30000, 45000, 60000, 75000, 90000);

        // Filter salaries greater than 50000
        salaries.stream()
                .filter(salary -> salary > 50000)

                // Print filtered salaries
                .forEach(System.out::println);
    }
}

Output:

60000
75000
90000

Explanation: The filter() method checks every salary and keeps only the values greater than 50,000.

Example 3: map()

The map() method is used to transform each element into another value.

Scenario: Increase every employee’s salary by 10%.

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

public class MapExample {

    public static void main(String[] args) {

        // Create a list of salaries
        List<Integer> salaries = Arrays.asList(30000, 40000, 50000);

        // Increase every salary by 10%
        salaries.stream()
                .map(salary -> salary + (salary * 10 / 100))

                // Print updated salaries
                .forEach(System.out::println);
    }
}

Output:

33000
44000
55000

Explanation: The map() method transforms every salary by adding 10%.

Example 4: sorted()

The sorted() method is used to sort elements in ascending or descending order.

Scenario: Sort employee salaries.

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

public class SortedExample {

    public static void main(String[] args) {

        // Create a list of salaries
        List<Integer> salaries = Arrays.asList(50000, 30000, 70000, 40000);

        // Sort salaries in ascending order
        salaries.stream()
                .sorted()
                .forEach(System.out::println);

        System.out.println("Descending Order:");

        // Sort salaries in descending order
        salaries.stream()
                .sorted(Comparator.reverseOrder())
                .forEach(System.out::println);
    }
}

Output:

30000
40000
50000
70000

Descending Order:
70000
50000
40000
30000

Example 5: distinct()

The distinct() method removes duplicate elements from a Stream.

Scenario: Remove duplicate employee IDs.

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

public class DistinctExample {

    public static void main(String[] args) {

        // Create a list containing duplicate IDs
        List<Integer> ids = Arrays.asList(101, 102, 101, 103, 102);

        // Remove duplicate IDs
        ids.stream()
           .distinct()
           .forEach(System.out::println);
    }
}

Output:

101
102
103

Example 6: collect()

The collect() method is used to collect processed Stream elements into a collection such as a List or Set.

Scenario: Get a new List containing salaries greater than 40,000.

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

public class CollectExample {

    public static void main(String[] args) {

        // Create a list of salaries
        List<Integer> salaries = Arrays.asList(30000, 45000, 60000, 75000);

        // Filter and collect salaries into a new list
        List<Integer> result = salaries.stream()
                .filter(salary -> salary > 40000)
                .collect(Collectors.toList());

        // Print the resulting list
        System.out.println(result);
    }
}

Output:

[45000, 60000, 75000]

Example 7: count()

The count() method returns the number of elements matching a condition.

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

public class CountExample {

    public static void main(String[] args) {

        // Create a list of numbers
        List<Integer> numbers = Arrays.asList(10, 20, 30, 40, 50);

        // Count numbers greater than 25
        long count = numbers.stream()
                .filter(number -> number > 25)
                .count();

        // Print the count
        System.out.println("Count: " + count);
    }
}

Output:

Count: 3

5. Real-World Example: Employee Management

Now let’s consider a practical scenario commonly found in enterprise applications.

Suppose we have an Employee class with the following properties:

• Employee ID
• Employee Name
• Department
• Salary

We need to find employees from the IT department whose salary is greater than 50,000.

Employee.java

public class Employee {   
 private int id;
    private String name;
    private String department;
    private double salary;

    // Constructor
    public Employee(int id, String name, String department, double salary) {
        this.id = id;
        this.name = name;
        this.department = department;
        this.salary = salary;
    }

    // Getter for employee name
    public String getName() {
        return name;
    }

    // Getter for department
    public String getDepartment() {
        return department;
    }

    // Getter for salary
    public double getSalary() {
        return salary;
    }
}

Main.java

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

public class Main {

    public static void main(String[] args) {

        // Create employee records
        List<Employee> employees = Arrays.asList(
            new Employee(1, "Akash", "IT", 60000),
            new Employee(2, "Rahul", "HR", 40000),
            new Employee(3, "Priya", "IT", 75000),
            new Employee(4, "Sneha", "Finance", 55000),
            new Employee(5, "Amit", "IT", 45000)
        );

        // Find IT employees earning more than 50000
        employees.stream()
                .filter(emp -> emp.getDepartment().equals("IT"))
                .filter(emp -> emp.getSalary() > 50000)

                // Print employee details
                .forEach(emp ->
                    System.out.println(
                        emp.getName() + " - " + emp.getSalary()
                    )
                );
    }
}

Output:

Akash - 60000.0
Priya - 75000.0

Real-world explanation:

In enterprise applications, we frequently need to filter employee records based on department, salary, status, or location. Instead of writing multiple nested loops and conditions, we can use Stream API to perform these operations in a clean and readable way.

6. Grouping Employees by Department

One of the useful features of Stream API is groupingBy().

Scenario: Group all employees according to their department.

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

public class GroupExample {

    public static void main(String[] args) {

        // Create a list of employees
        List<Employee> employees = Arrays.asList(
            new Employee(1, "Akash", "IT", 60000),
            new Employee(2, "Rahul", "HR", 40000),
            new Employee(3, "Priya", "IT", 75000),
            new Employee(4, "Sneha", "Finance", 55000)
        );

        // Group employees by department
        Map<String, List<Employee>> result = employees.stream()
            .collect(Collectors.groupingBy(Employee::getDepartment));

        // Print department names and employee counts
        result.forEach((department, employeeList) ->
            System.out.println(department + " : " + employeeList.size())
        );
    }
}

Output:

IT : 2
HR : 1
Finance : 1

7. Difference Between map() and flatMap()

Both methods are used for data transformation, but they work differently.

map() flatMap() Transforms each element into one result Transforms each element into a Stream and flattens the results One-to-one mapping One-to-many mapping is possible Does not flatten nested collections Flattens nested collections

Example using flatMap():

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

public class FlatMapExample {

    public static void main(String[] args) {

        // Create a list containing multiple lists
        List<List<String>> names = Arrays.asList(
            Arrays.asList("Akash", "Rahul"),
            Arrays.asList("Priya", "Sneha")
        );

        // Flatten nested lists into a single stream
        List<String> result = names.stream()
                .flatMap(list -> list.stream())
                .collect(Collectors.toList());

        // Print flattened list
        System.out.println(result);
    }
}

Output:

[Akash, Rahul, Priya, Sneha]

8. What is the difference between Intermediate and Terminal Operations?

Intermediate Operations Terminal Operations Return another Stream Produce a final result or side effect Lazy in execution Trigger Stream execution Can be chained End the Stream pipeline Examples: filter(), map(), sorted()Examples: collect(), count(), forEach()

Important concept: Lazy Evaluation

Intermediate operations are not executed immediately. They are executed only when a terminal operation is invoked.

For example:

numbers.stream()
       .filter(n -> n > 20)
       .map(n -> n * 2)
       .collect(Collectors.toList());

The filter() and map() operations are executed when collect() triggers the Stream pipeline.

9. What is Parallel Stream?

Java 8 also introduced parallelStream(), which allows collection elements to be processed using multiple threads through the ForkJoin common pool.

Example:

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

public class ParallelStreamExample {

    public static void main(String[] args) {

        // Create a list of numbers
        List<Integer> numbers = Arrays.asList(10, 20, 30, 40, 50);

        // Process elements using a parallel stream
        numbers.parallelStream()
               .forEach(number ->
                   System.out.println(
                       number + " : " +   Thread.currentThread().getName()
                   )
               );
    }
}

Sample output:

30 : main
20 : ForkJoinPool.commonPool-worker-1
10 : ForkJoinPool.commonPool-worker-2
40 : main
50 : ForkJoinPool.commonPool-worker-1

Note: The output order and thread names can vary between executions.

When should we use Parallel Streams?

• When processing large datasets.
• When operations are independent.
• When the workload benefits from parallel execution.

Avoid using parallel streams blindly. They can introduce overhead, thread contention, and ordering issues. Always measure performance before choosing them.

10. Important Things to Remember

• Streams do not modify the original collection by default.
• A Stream cannot be reused after a terminal operation.
• Intermediate operations are lazy.
• filter() is used for selecting elements.
• map() is used for transforming elements.
• flatMap() is used for flattening nested structures.
• collect() is used for collecting results.
• groupingBy() is useful for grouping records.
• parallelStream() supports parallel processing, but is not always faster.

Conclusion

Java 8 Stream API makes collection processing easier, cleaner, and more readable. It provides powerful operations such as filter(), map(), sorted(), distinct(), collect(), and groupingBy() that help developers write maintainable code.

For Java developers working with enterprise applications, Stream API is particularly useful when processing employee records, filtering orders, calculating salaries, grouping transactions, and transforming database results.

If you are learning Java 8, I recommend practicing these operations with real-world examples rather than memorizing only their definitions.

Keep learning, keep coding, and keep sharing your knowledge!

Suggested Medium topics:

Java, Programming, Software Development, Technology, Java 8