ImmutableMap, as suggested by the name, is a type of Map which is immutable. It means that the content of the map are fixed or constant after declaration, that is, they are read-only.
If any attempt made to add, delete and update elements in the Map, UnsupportedOperationException is thrown.
An ImmutableMap does not allow null element either.
If any attempt made to create an ImmutableMap with null element, NullPointerException is thrown. If any attempt is made to add null element in Map, UnsupportedOperationException is thrown.
Advantages of ImmutableMap
- They are thread safe.
- They are memory efficient.
- Since they are immutable, hence they can be passed over to third party libraries without any problem.
- Note that it is an immutable collection, not collection of immutable objects, so the objects inside it can be modified.
Class Declaration:
@GwtCompatible(serializable=true,
emulated=true)
public abstract class ImmutableMap
extends Object
implements Map, Serializable
Class hierarchy:
java.lang.Object
↳ com.google.common.collect.ImmutableMap
Creating ImmutableMap
ImmutableMap can be created by various methods. These include:
From existing Map using copyOf() function of Guava
// Below is the Java program to create ImmutableMap
import com.google.common.collect.ImmutableMap;
import java.util.HashMap;
import java.util.Map;
class MapUtil {
// Function to create ImmutableMap from Map
public static <K, T> void iMap(Map<K, T> map)
{
// Create ImmutableMap from Map using copyOf()
ImmutableMap<K, T> immutableMap = ImmutableMap.copyOf(map);
// Print the ImmutableMap
System.out.println(immutableMap);
}
public static void main(String[] args)
{
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "Prutor");
map.put(2, "Ai");
map.put(3, "Prutor");
iMap(map);
}
}
result:
{1=Prutor, 2=For, 3=Prutor}
New ImmutableMap using of() function from Guava
// Below is the Java program to create ImmutableMap
import com.google.common.collect.ImmutableMap;
import java.util.HashMap;
import java.util.Map;
class MapUtil {
// Function to create ImmutableMap
public static void createImmutableMap()
{
// Create ImmutableMap using of()
ImmutableMap<Integer, String> immutableMap = ImmutableMap.of(
1, "Prutor",
2, "Ai",
3, "Prutor");
// Print the ImmutableMap
System.out.println(immutableMap);
}
public static void main(String[] args)
{
createImmutableMap();
}
}
result:
{1=Prutor, 2=For, 3=Prutor}
Using Java 9 Factory Of() method
In Java, use of() with Set, Map or List to create an Immutable Map.
Please Note: The programs below are of Java 9. Hence you would need a Java 9 compiler to run them.
// Java code illustrating of() method to
// create a ImmutableSet
import java.util.*;
import com.google.common.collect.ImmutableMap;
class PAI {
public static void main(String args[])
{
// non-empty immutable set
Map<Integer, String> map = Map.of(
1, "Prutor",
2, "Ai",
3, "Prutor");
// Let's print the set
System.out.println(map);
}
}
result:
{1=Prutor, 2=For, 3=Prutor}
Using Builder() from ImmutableMap
In Guava, ImmnutableMap class provides a function Builder(). Through this function, a new ImmutableMap can be created, or
an ImmutableMap can be created from an existing Map or both.
Creating a new ImmutableMap
// Java code illustrating of() method to
// create a ImmutableSet
import java.util.*;
import com.google.common.collect.ImmutableMap;
class PAI {
public static void main(String args[])
{
// non-empty immutable set
ImmutableMap<Integer, String> imap =
ImmutableMap.<Integer, String>builder()
.put(1, "Prutor")
.put(2, "Ai")
.put(3, "Prutor")
.build();
// Let's print the set
System.out.println(imap);
}
}
result:
{1=Prutor, 2=For, 3=Prutor}
Creating an ImmutableMap from existing Map
// Java code illustrating of() method to
// create a ImmutableSet
import java.util.*;
import com.google.common.collect.ImmutableMap;
class PAI {
public static void main(String args[])
{
// non-empty immutable set
Map<Integer, String> map = Map.of(1, "Prutor",
2, "Ai",
3, "Prutor");
ImmutableMap<Integer, String> imap =
ImmutableMap.<Integer, String>builder()
.putAll(map)
.build();
// Let's print the set
System.out.println(imap);
}
}
result:
{1=Prutor, 2=For, 3=Prutor}
Creating a new ImmutableMap including the existing Map
// Java code illustrating of() method to
// create a ImmutableSet
import java.util.*;
import com.google.common.collect.ImmutableMap;
class PAI {
public static void main(String args[])
{
// non-empty immutable set
Map<Integer, String> map = Map.of(1, "Prutor",
2, "Ai",
3, "Prutor");
ImmutableMap<Integer, String> imap =
ImmutableMap.<Integer, String>builder()
.putAll(map)
.put(4, "Computer")
.put(5, "Portal")
.build();
// Let's print the set
System.out.println(imap);
}
}
result:
{1=Prutor, 2=For, 3=Prutor, 4=Computer, 5=Portal}
Try to change ImmutableMap
As mentioned earlier, the below program will throw UnsupportedOperationException.
// Java code to show that UnsupportedOperationException
// will be thrown when ImmutableMap is modified.
import java.util.*;
class PAI {
public static void main(String args[])
{
// empty immutable map
Map<Integer, String> map = Map.of();
// Lets try adding element in these set
map.put(1, "Prutor");
map.put(2, "Ai");
map.put(3, "Prutor");
}
}
Result :
Exception in thread "main" java.lang.UnsupportedOperationException
at com.google.common.collect.ImmutableCollection.add(ImmutableCollection.java:218)
at ImmutableListDemo.main(Main.java:16)
How is it different from Collections.unmodifiableMap()?
Collections.unmodifiableMap creates a wrapper around the same existing Map such that the wrapper cannot be used to modify it. However we can still change original Map.
// Java program to demonstrate that a Map created using
// Collections.unmodifiableMap() can be modified indirectly.
import java.io.*;
import java.util.*;
class PAI {
public static void main(String[] args)
{
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "Prutor");
map.put(2, "Ai");
map.put(3, "Prutor");
// Create ImmutableMap from Map using copyOf()
Map<Integer, String> imap = Collections.unmodifiableMap(map);
// We change map and the changes reflect in imap.
map.put(4, "Computer");
map.put(5, "Portal");
System.out.println(imap);
}
}
result:
{1=Prutor, 2=For, 3=Prutor, 4=Computer, 5=Portal}
If we create an ImmutableMap from an existing Map and change the existing Map, the ImmutableMap does not change because a copy is created.
// Below is a Java program for
// Creating an immutable Map using copyOf()
// and modifying original Map.
import java.io.*;
import java.util.*;
import com.google.common.collect.ImmutableMap;
class PAI {
public static void main(String[] args)
{
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "Prutor");
map.put(2, "Ai");
map.put(3, "Prutor");
// Create ImmutableMap from Map using copyOf()
ImmutableMap<Integer, String> imap = ImmutableMap.copyOf(map);
// We change map and the changes wont reflect in imap.
map.put(4, "Computer");
map.put(5, "Portal");
System.out.println(imap);
}
}
Result :
{1=Prutor, 2=For, 3=Prutor}