Java Map ofEntries()

Introduction

The Map.ofEntries method, introduced in Java 9, provides a convenient way to create immutable maps. This method belongs to the java.util.Map interface and allows you to create a map with a fixed set of key-value pairs. The maps created using Map.ofEntries are immutable, meaning that their entries cannot be changed, added, or removed once the map is created.

Key Points:

• Immutability: The map created using Map.ofEntries is immutable.
• Convenience: Provides a simple and concise way to create maps with a fixed set of key-value pairs.
• Null Keys and Values Not Allowed: The map cannot contain null keys or values.
• No Duplicate Keys: The map cannot contain duplicate keys.

Table of Contents

1. Creating Maps with Map.ofEntries
2. Characteristics of Map.ofEntries
3. Common Use Cases
4. Examples
5. Conclusion

1. Creating Maps with Map.ofEntries

The Map.ofEntries method provides a convenient way to create maps using a series of key-value pairs. You use the Map.entry(K, V) method to create these key-value pairs.

Example:

import java.util.Map;
import java.util.Map.Entry;

public class MapOfEntriesExample {
    public static void main(String[] args) {
        // Creating a map with multiple entries
        Map<String, Integer> ageMap = Map.ofEntries(
            Map.entry("Alice", 30),
            Map.entry("Bob", 25),
            Map.entry("Charlie", 35)
        );

        System.out.println("Age Map: " + ageMap);
    }
}

Explanation:

• Map.ofEntries(…): Creates an immutable map with the specified key-value pairs.
• Map.entry("Alice", 30): Creates a key-value pair with the key "Alice" and the value 30.

2. Characteristics of Map.ofEntries

Maps created using Map.ofEntries have the following characteristics:

• Immutable: The map cannot be modified (i.e., no entries can be added, removed, or changed).
• Null Keys and Values Not Allowed: Attempting to create a map with null keys or values will throw a NullPointerException.
• No Duplicate Keys: Attempting to create a map with duplicate keys will throw an IllegalArgumentException.
• Fixed Size: The size of the map is fixed at the time of creation.

Example:

import java.util.Map;

public class MapCharacteristicsExample {
    public static void main(String[] args) {
        Map<String, Integer> map = Map.ofEntries(
            Map.entry("one", 1),
            Map.entry("two", 2),
            Map.entry("three", 3)
        );

        // Attempting to modify the map will throw UnsupportedOperationException
        try {
            map.put("four", 4);
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot add entries to the map: " + e);
        }

        try {
            map.remove("one");
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot remove entries from the map: " + e);
        }

        try {
            Map.ofEntries(Map.entry("one", null));
        } catch (NullPointerException e) {
            System.out.println("Cannot create a map with null values: " + e);
        }

        try {
            Map.ofEntries(Map.entry("one", 1), Map.entry("one", 2));
        } catch (IllegalArgumentException e) {
            System.out.println("Cannot create a map with duplicate keys: " + e);
        }
    }
}

Explanation:

• map.put("four", 4): Attempting to add an entry to the map throws an UnsupportedOperationException.
• map.remove("one"): Attempting to remove an entry from the map throws an UnsupportedOperationException.
• Map.ofEntries(Map.entry("one", null)): Attempting to create a map with null values throws a NullPointerException.
• Map.ofEntries(Map.entry("one", 1), Map.entry("one", 2)): Attempting to create a map with duplicate keys throws an IllegalArgumentException.

3. Common Use Cases

Use Case 1: Creating a Read-Only Map

When you need a map that should not be modified, Map.ofEntries is an excellent choice.

Example:

import java.util.Map;

public class ReadOnlyMapExample {
    public static void main(String[] args) {
        Map<String, String> countryCapitalMap = Map.ofEntries(
            Map.entry("USA", "Washington, D.C."),
            Map.entry("Canada", "Ottawa"),
            Map.entry("UK", "London")
        );

        System.out.println("Country-Capital Map: " + countryCapitalMap);
    }
}

Use Case 2: Providing Fixed Data for Testing

When writing tests, you might need a map with a fixed set of key-value pairs.

Example:

import java.util.Map;

public class FixedDataMapExample {
    public static void main(String[] args) {
        Map<String, Integer> scoreMap = Map.ofEntries(
            Map.entry("Alice", 85),
            Map.entry("Bob", 90),
            Map.entry("Charlie", 95)
        );

        System.out.println("Score Map: " + scoreMap);
    }
}

4. Examples

Example 1: Creating a Map of String Keys and Integer Values

import java.util.Map;

public class StringIntegerMapExample {
    public static void main(String[] args) {
        Map<String, Integer> ages = Map.ofEntries(
            Map.entry("John", 28),
            Map.entry("Jane", 32),
            Map.entry("Tom", 24)
        );

        System.out.println("Ages: " + ages);
    }
}

Example 2: Creating a Map of Integer Keys and String Values

import java.util.Map;

public class IntegerStringMapExample {
    public static void main(String[] args) {
        Map<Integer, String> months = Map.ofEntries(
            Map.entry(1, "January"),
            Map.entry(2, "February"),
            Map.entry(3, "March")
        );

        System.out.println("Months: " + months);
    }
}

Example 3: Attempting to Modify the Map

import java.util.Map;

public class ModifyMapExample {
    public static void main(String[] args) {
        Map<String, String> immutableMap = Map.ofEntries(
            Map.entry("a", "apple"),
            Map.entry("b", "banana"),
            Map.entry("c", "cherry")
        );

        // Trying to add an entry
        try {
            immutableMap.put("d", "date");
        } catch (UnsupportedOperationException e) {
            System.out.println("Add operation not supported: " + e);
        }

        // Trying to remove an entry
        try {
            immutableMap.remove("a");
        } catch (UnsupportedOperationException e) {
            System.out.println("Remove operation not supported: " + e);
        }

        // Trying to modify an entry
        try {
            immutableMap.put("a", "apricot");
        } catch (UnsupportedOperationException e) {
            System.out.println("Modify operation not supported: " + e);
        }
    }
}

Example 4: Null Keys and Values Not Allowed

import java.util.Map;

public class NullElementMapExample {
    public static void main(String[] args) {
        try {
            Map<String, String> mapWithNullKey = Map.ofEntries(Map.entry(null, "value"));
        } catch (NullPointerException e) {
            System.out.println("Null keys not allowed: " + e);
        }

        try {
            Map<String, String> mapWithNullValue = Map.ofEntries(Map.entry("key", null));
        } catch (NullPointerException e) {
            System.out.println("Null values not allowed: " + e);
        }
    }
}

Example 5: Duplicate Keys Not Allowed

import java.util.Map;

public class DuplicateKeyMapExample {
    public static void main(String[] args) {
        try {
            Map<String, Integer> mapWithDuplicateKeys = Map.ofEntries(
                Map.entry("one", 1),
                Map.entry("one", 2)
            );
        } catch (IllegalArgumentException e) {
            System.out.println("Duplicate keys not allowed: " + e);
        }
    }
}

5. Conclusion

The Map.ofEntries method provides a convenient way to create immutable maps in Java. It offers a simple and concise syntax for creating maps with a fixed set of key-value pairs. By understanding the characteristics and use cases of Map.ofEntries, you can effectively utilize this method to create read-only maps, provide fixed data for testing, and improve the maintainability of your code.