Java 8 – Iterate Over a Map

Introduction

Iterating over a Map is a common task in Java, especially when you need to access or manipulate the key-value pairs stored within it. Before Java 8, typical methods for iterating over a map involved using entrySet(), keySet(), or values() in conjunction with loops. Java 8 introduced the Stream API and other features that provide more powerful and flexible ways to iterate over a map. These methods not only make the code more concise but also allow for more complex operations to be performed on the map entries while iterating. In this guide, we’ll explore different ways to iterate over a map in Java 8, including traditional methods and new approaches using lambdas and streams.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Iterating Over a Map Using entrySet()
  • Iterating Over a Map Using forEach()
  • Iterating Over a Map Using Streams
• Advanced Considerations
• Conclusion

Problem Statement

The task is to create a Java program that:

• Accepts a map of key-value pairs.
• Iterates over the map using different methods.
• Performs operations on each key-value pair during iteration.

Example:

• Input: Map {1: "Apple", 2: "Banana", 3: "Orange"}
• Output: Print each key-value pair in a formatted string, e.g., Key: 1, Value: Apple.

Solution Steps

1. Create a Map: Start with a map of key-value pairs.
2. Iterate Over the Map: Use various methods to iterate over the map.
3. Perform Operations: During iteration, perform operations on the key-value pairs, such as printing them out or modifying the map.
4. Display the Result: Print the key-value pairs during iteration.

Java Program

Iterating Over a Map Using entrySet()

The most traditional way to iterate over a map is by using the entrySet() method, which provides a set of all key-value pairs in the map. This can be done with a for-each loop.

import java.util.Map;

/**
 * Java 8 - Iterate Over a Map Using entrySet()
 * Author: https://www.rameshfadatare.com/
 */
public class IterateMapUsingEntrySet {

    public static void main(String[] args) {
        // Step 1: Create a map
        Map<Integer, String> map = Map.of(
            1, "Apple",
            2, "Banana",
            3, "Orange"
        );

        // Step 2: Iterate over the map using entrySet()
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            // Step 3: Perform operation on each key-value pair
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

Output

Key: 1, Value: Apple
Key: 2, Value: Banana
Key: 3, Value: Orange

Explanation

• The entrySet() method returns a set view of the map’s key-value pairs.
• The for-each loop iterates over this set, providing access to each Map.Entry object, which contains both the key and the value.

Iterating Over a Map Using forEach()

Java 8 introduced the forEach() method in the Map interface, which allows you to iterate over the map more concisely using a lambda expression.

import java.util.Map;

/**
 * Java 8 - Iterate Over a Map Using forEach()
 * Author: https://www.rameshfadatare.com/
 */
public class IterateMapUsingForEach {

    public static void main(String[] args) {
        // Step 1: Create a map
        Map<Integer, String> map = Map.of(
            1, "Apple",
            2, "Banana",
            3, "Orange"
        );

        // Step 2: Iterate over the map using forEach()
        map.forEach((key, value) -> {
            // Step 3: Perform operation on each key-value pair
            System.out.println("Key: " + key + ", Value: " + value);
        });
    }
}

Output

Key: 1, Value: Apple
Key: 2, Value: Banana
Key: 3, Value: Orange

Explanation

• The forEach() method takes a BiConsumer (a lambda expression with two parameters) that operates on each key-value pair in the map.
• This method is more concise and eliminates the need for explicit Map.Entry objects.

Iterating Over a Map Using Streams

The Stream API provides a way to iterate over a map with additional flexibility, such as filtering, mapping, and collecting the entries into other collections.

import java.util.Map;
import java.util.stream.Collectors;

/**
 * Java 8 - Iterate Over a Map Using Streams
 * Author: https://www.rameshfadatare.com/
 */
public class IterateMapUsingStreams {

    public static void main(String[] args) {
        // Step 1: Create a map
        Map<Integer, String> map = Map.of(
            1, "Apple",
            2, "Banana",
            3, "Orange"
        );

        // Step 2: Iterate over the map using streams
        map.entrySet()
            .stream()
            .filter(entry -> entry.getKey() % 2 == 0) // Example: Filter even keys
            .forEach(entry -> {
                // Step 3: Perform operation on each filtered key-value pair
                System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
            });

        // Additional example: Collect map entries with even keys into a new map
        Map<Integer, String> evenKeyMap = map.entrySet()
            .stream()
            .filter(entry -> entry.getKey() % 2 == 0)
            .collect(Collectors.toMap(
                Map.Entry::getKey,
                Map.Entry::getValue
            ));

        System.out.println("Filtered Map with Even Keys: " + evenKeyMap);
    }
}

Output

Key: 2, Value: Banana
Filtered Map with Even Keys: {2=Banana}

Explanation

• The entrySet().stream() method creates a stream of map entries.
• The filter() method allows you to include only certain entries in the iteration.
• The forEach() method processes the filtered entries.
• In the additional example, the filtered entries are collected into a new map using Collectors.toMap().

Advanced Considerations

• Parallel Streams: If the map is large and operations on its entries are independent, you can use parallel streams to improve performance: map.entrySet().parallelStream().forEach(...).

• Null Handling: If the map contains null keys or values, ensure that your iteration logic handles them appropriately to avoid NullPointerException.

• Immutable Maps: If you need to ensure that the map remains immutable during iteration, consider using Collections.unmodifiableMap() to wrap the original map before iterating.

Conclusion

This guide provides methods for iterating over a map in Java 8, covering traditional approaches with entrySet() as well as modern approaches using forEach() and the Stream API. Iterating over a map is a fundamental task in many Java applications, and Java 8’s features provide more powerful, flexible, and concise ways to perform this operation. Depending on your specific use case, you can choose the method that best fits your needs for iterating over maps in Java.