Initializing Maps in Java

In Java, maps are a fundamental data structure used to store key-value pairs. Initializing a map can be done in several ways, depending on the Java version and the desired level of immutability. This tutorial will cover the different methods for initializing maps in Java.

Using the Constructor

The most basic way to initialize a map is by using its constructor and adding elements manually:

Map<String, String> myMap = new HashMap<>();
myMap.put("a", "b");
myMap.put("c", "d");

This approach can be tedious if you need to add many elements.

Double Brace Initialization

Another way to initialize a map is by using the double brace initialization:

Map<String, String> myMap = new HashMap<String, String>() {{
    put("a", "b");
    put("c", "d");
}};

This method creates an anonymous subclass of HashMap and initializes it with the given elements. However, this approach can have unwanted side effects, such as generating an additional class file and holding a reference to the outer object.

Java 9+ Factory Methods

In Java 9 and later, you can use the Map.of() and Map.ofEntries() factory methods to initialize maps:

// Up to 10 elements
Map<String, String> myMap = Map.of(
    "a", "b",
    "c", "d"
);

// Any number of elements
import static java.util.Map.entry;
Map<String, String> myMap2 = Map.ofEntries(
    entry("a", "b"),
    entry("c", "d")
);

These methods create immutable maps. If you need a mutable map, you can pass the result to the HashMap constructor:

Map<String, String> myMap = new HashMap<>(Map.of("a", "b", "c", "d"));

Guava Library

If you’re using the Guava library, you can use its ImmutableMap class to initialize maps:

import com.google.common.collect.ImmutableMap;
Map<String, String> myMap = ImmutableMap.of("a", "b", "c", "d");

This method creates an immutable map with up to 5 elements. For more elements, you can use the Builder class:

Map<String, String> myMap = new ImmutableMap.Builder<String, String>()
    .put("a", "b")
    .put("c", "d")
    // ...
    .build();

Conclusion

Initializing maps in Java can be done using various methods, each with its own trade-offs. The choice of method depends on the specific requirements of your application, such as immutability and performance.