HashMap is a commonly used data structure in Java that stores key-value pairs. Sometimes, there is a need to create a copy or clone of an existing HashMap for various purposes. In this blog post, we will explore how to clone a HashMap in Java.
Table of Contents
Introduction
Cloning a HashMap means creating a new instance of HashMap with the same key-value pairs as the original HashMap. It is important to understand the difference between shallow cloning and deep cloning in this context.
Shallow Cloning
Shallow cloning refers to creating a new HashMap instance where the keys and values still refer to the same objects as the original HashMap. In other words, changes made to the objects in either the original or cloned HashMap will reflect in both.
To perform shallow cloning, we can use the clone() method provided by the HashMap class. Here’s an example:
HashMap<Integer, String> originalHashMap = new HashMap<>();
originalHashMap.put(1, "one");
originalHashMap.put(2, "two");
HashMap<Integer, String> clonedHashMap = (HashMap<Integer, String>) originalHashMap.clone();
clonedHashMap.put(3, "three");
System.out.println(originalHashMap); // Output: {1=one, 2=two, 3=three}
System.out.println(clonedHashMap); // Output: {1=one, 2=two, 3=three}
As you can see, modifying the cloned HashMap also affects the original HashMap. This is because the keys and values are still referencing the same objects.
Deep Cloning
Deep cloning, on the other hand, involves creating a new HashMap instance where the keys and values refer to separate copies of the original objects. Changes made to the objects in either the original or cloned HashMap will not affect each other.
To achieve deep cloning, we need to manually iterate over the original HashMap and create new instances of the objects within the cloned HashMap. Here’s an example:
HashMap<Integer, String> originalHashMap = new HashMap<>();
originalHashMap.put(1, "one");
originalHashMap.put(2, "two");
HashMap<Integer, String> clonedHashMap = new HashMap<>();
for (Map.Entry<Integer, String> entry : originalHashMap.entrySet()) {
clonedHashMap.put(entry.getKey(), new String(entry.getValue()));
}
clonedHashMap.put(3, "three");
System.out.println(originalHashMap); // Output: {1=one, 2=two}
System.out.println(clonedHashMap); // Output: {1=one, 2=two, 3=three}
In the above example, we create new String objects for the values while iterating over the original HashMap. This ensures that changes made to the values in one HashMap do not affect the other.
Conclusion
Cloning a HashMap in Java allows us to create a duplicate of an existing HashMap. Depending on the scenario, we can choose between shallow cloning, where the keys and values reference the same objects, or deep cloning, where the keys and values refer to separate copies of the original objects.