Java Stream forEach() Method

The forEach() method in Java is a part of the java.util.stream.Stream interface. In this guide, we will learn how to use forEach() method in Java with practical examples and real-world use cases to better understand its usage.

Table of Contents

1. Introduction
2. forEach() Method Syntax
3. Examples
   • Basic Usage
   • Using forEach() with Complex Operations
4. Real-World Use Cases
   • Logging User Activities
   • Sending Emails
   • Updating Database Records
5. Conclusion

Introduction

The Stream.forEach() method in Java is used to perform an action on each element of the stream. It applies the given operation to every element in the stream.

This method is useful when you want to iterate over all elements and perform side effects like printing or modifying external data.

forEach() is commonly used for simple tasks such as printing elements but should be used carefully as it doesn’t preserve stream order in parallel streams.

forEach() Method Syntax

The syntax for the forEach() method is as follows:

void forEach(Consumer<? super T> action)

Parameters:

• action: A Consumer that defines the operation to be performed on each element of the stream.

Returns:

• The method does not return a value.

Throws:

• The forEach() method doesn’t throw exceptions directly, but exceptions may be propagated from the operation defined in the Consumer.

Understanding forEach()

The forEach() method iterates through the stream and applies the specified action on each element. It is primarily used to perform side-effects, such as logging, printing, or modifying shared data structures. This method is a terminal operation, meaning it consumes the stream, and no further operations can be applied after it.

Examples

Basic Usage

Let’s start with a simple example that demonstrates how to use forEach() to print the elements of a stream:

import java.util.stream.Stream;

public class ForEachExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("apple", "banana", "cherry");

        // Use forEach() to print each element
        stream.forEach(System.out::println);
    }
}

Output:

apple
banana
cherry

Using forEach() with Complex Operations

Here’s an example where we use forEach() to perform more complex operations, such as calculating and printing the length of each string:

import java.util.stream.Stream;

public class ForEachComplexExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("apple", "banana", "cherry");

        // Use forEach() to print the length of each element
        stream.forEach(s -> System.out.println(s + " has length " + s.length()));
    }
}

Output:

apple has length 5
banana has length 6
cherry has length 6

Real-World Use Cases

Example 1: Logging User Activities

In a real-world application, you can use forEach() to log user activities from a stream of user actions:

import java.util.stream.Stream;

public class LogUserActivitiesExample {
    static class UserAction {
        String user;
        String action;

        UserAction(String user, String action) {
            this.user = user;
            this.action = action;
        }

        @Override
        public String toString() {
            return user + " performed " + action;
        }
    }

    public static void main(String[] args) {
        Stream<UserAction> actions = Stream.of(
            new UserAction("Alice", "login"),
            new UserAction("Bob", "view page"),
            new UserAction("Charlie", "logout")
        );

        // Use forEach() to log each user action
        actions.forEach(action -> System.out.println("Logging: " + action));
    }
}

Output:

Logging: Alice performed login
Logging: Bob performed view page
Logging: Charlie performed logout

Example 2: Sending Emails to Users

Here’s another real-world use case where we send an email to each user in a list using the forEach() method:

import java.util.stream.Stream;

public class SendEmailsExample {
    static class User {
        String email;

        User(String email) {
            this.email = email;
        }

        @Override
        public String toString() {
            return email;
        }
    }

    public static void main(String[] args) {
        Stream<User> users = Stream.of(
            new User("alice@example.com"),
            new User("bob@example.com"),
            new User("charlie@example.com")
        );

        // Use forEach() to send an email to each user
        users.forEach(user -> System.out.println("Sending email to: " + user));
    }
}

Output:

Sending email to: alice@example.com
Sending email to: bob@example.com
Sending email to: charlie@example.com

Example 3: Updating Database Records

In this example, we use forEach() to update user records in a database. Assume we have a list of users, and we need to mark each of them as active:

import java.util.stream.Stream;

public class UpdateUserRecordsExample {
    static class User {
        String name;
        boolean active;

        User(String name) {
            this.name = name;
            this.active = false;  // Initially inactive
        }

        void activate() {
            this.active = true;
        }

        @Override
        public String toString() {
            return name + " (Active: " + active + ")";
        }
    }

    public static void main(String[] args) {
        Stream<User> users = Stream.of(
            new User("Alice"),
            new User("Bob"),
            new User("Charlie")
        );

        // Use forEach() to activate each user
        users.forEach(user -> {
            user.activate();
            System.out.println("User updated: " + user);
        });
    }
}

Output:

User updated: Alice (Active: true)
User updated: Bob (Active: true)
User updated: Charlie (Active: true)

Conclusion

The Stream.forEach() method is used to perform an action for each element of the stream. This method is particularly useful for iterating over a stream and applying a specified operation to each element, such as printing or modifying external data structures.

By understanding and using this method, you can efficiently manage and process streams of values in your Java applications, performing necessary operations on each element as needed.