Clone HashMap in Java

In Java, HashMap is a Hashtable-based implementation. The implementation of the HashMap allows us to apply all the optional Map operations like add data to Map, delete data from the Map, retrieve key-value from the Map, determine the Map size, etc. Besides these, we can also create a clone or copy of a Map. In this section, we will learn how to clone HashMap in Java.

Java HashMap

Java HashMap class implements the Map interface which allows us to store key and value pairs, where keys should be unique. If we try to insert the duplicate key, it will replace the element of the corresponding key. It is easy to perform operations using the key index like updation, deletion, etc. The Java HashMap class belongs to java.util package.

HashMap in Java is like the legacy Hashtable class, but it is not synchronized. It allows us to store the null elements as well, but there should be only one null key. Since Java 5, it is denoted as HashMap<K, V>, where K stands for key and V for value. It inherits the AbstractMap class and implements the Map interface.

Methods to Clone a HashMap

There are the following ways to clone a Map in Java:

Naive Solution
Using Map.putAll() Method
Using Copy Constructor
Using Java 8 Stream
Using Google's JSON Library
Using HashMap.clone() Method

Naive Solution

It is the simplest way to clone a HashMap. In this method, we iterate the HashMap and invoke the put(k, v) method once for each mapping from key to value. Let's see a program for the same.

CloneHashMapExample1.java

import java.util.HashMap;
import java.util.Map;
public class CloneHashMapExample1
{
//user-defined clone() method that clones the instance of the Map    
public static<K, V> Map<K, V> cloneMap(Map<K, V> originalmap) 
{
//creating an instance of the HashMap    
Map<K, V> copy = new HashMap<>();
//loop iterate over the key value pair
for (Map.Entry<K, V> entry: originalmap.entrySet()) 
{
//geting key-value pair    
copy.put(entry.getKey(), entry.getValue());
}
//returns a copy of the HashMap instance
return copy;
}
//driver code
public static void main(String args[]) 
{
Map<String, Integer> hashMap = new HashMap();
//putting values to the HashMap
hashMap.put("India", 101);
hashMap.put("Nepal", 76);
hashMap.put("Sri Lanka", 65);
hashMap.put("Bangladesh", 75);
//calling the user defined clone() method and parsing the map into it
Map<String, Integer> copy = cloneMap(hashMap);
//prints the key-value pair
System.out.println(copy);
}
}

Output:

{Bangladesh=75, Sri Lanka=65, Nepal=76, India=101}

Using Map.putAll() Method

Another way to clone a map is to use the putAll() method. It copies all the mapping from the original map to an empty map.

CloneHashMapExample2.java

import java.util.HashMap;
import java.util.Map;
public class CloneHashMapExample2
{
//user-defined method that clone a HashMap and return the Map instance    
public static<K, V> Map<K, V> cloneMap(Map<K, V> originalmap)
{
//creating an instance of the Map    
Map<K, V> copy = new HashMap<>();
//invoking the putAll() method
copy.putAll(originalmap);
//returns a copy of the Map
return copy;
}
//driver code
public static void main(String args[])
{
//creating an instance of the map    
Map<String, Integer> hashMap = new HashMap();
//putting values to the Map
hashMap.put("MCA", 90);
hashMap.put("B.Tech", 120);
hashMap.put("M.Tech", 60);
hashMap.put("B.Pharma", 50);
hashMap.put("B.Arch", 200);
Map<String, Integer> copy = cloneMap(hashMap);
//prints the 
System.out.println(copy);
}
}

Output:

{M.Tech=60, MCA=90, B.Arch=200, B.Tech=120, B.Pharma=50}

Using Copy Constructor

We can also use a copy constructor to clone a map. In this method, a constructor of the Map is used to create a new object as a copy of an existing object.

CloneHashMapExample3.java

import java.util.HashMap;
import java.util.Map;
public class CloneHashMapExample3
{
//user-defined method to clone a Map    
public static<K, V> Map<K, V> cloneMap(Map<K, V> originalmap) 
{
//returns a new HashMap    
return new HashMap<>(originalmap);
}
//driver code
public static void main(String args[])
{
//creating an instance of the HashMap    
Map<String, Integer> hashMap = new HashMap();
//adding key-value pair to Map
hashMap.put("One", 1);
hashMap.put("Two", 2);
hashMap.put("Three", 3);
hashMap.put("Four", 4);
hashMap.put("Five", 5);
Map<String, Integer> copy = cloneMap(hashMap);
//prints the cloned map
System.out.println(copy);
}
}

Output:

{Five=5, Two=2, Three=3, One=1, Four=4}

Using Java 8 Stream

Java Stream API can also be used to clone a HashMap. Let's see an example.

CloneHashMapExample4.java

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
public class CloneHashMapExample4
{
public static<K, V> Map<K, V> clone(Map<K, V> originalmap)
{
return originalmap.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}
//driver code
public static void main(String args[])
{
//creating an instance of the HashMap        
Map<String, Double> hashMap = new HashMap();
//adding key-value pair to Map
hashMap.put("Mac Book", 67000.00);
hashMap.put("Acer Pro", 55000.00);
hashMap.put("HP Note Book", 45000.00);
hashMap.put("Dell PC", 34000.00);
hashMap.put("Asus Gaming Laptop", 89000.00);
Map<String, Double> copy = clone(hashMap);
//prints the cloned map
System.out.println(copy);
}
}

Output:

{Mac Book=67000.0, Dell PC=34000.0, Acer Pro=55000.0, Asus Gaming Laptop=89000.0, HP Note Book=45000.0}

Using Google's JSON Library

Another way to clone a HashMap is to use Google's JSON library. In this method, first, convert the map to JSON string and JSON string back to a new map object. It works the same as the serialized object holds no reference to the original object on deserialization.

CloneHashMapExample5.java

import com.google.gson.Gson;
import java.util.HashMap;
import java.util.Map;
public class CloneHashMapExample5
{
//user-defined method to clone a Map    
public static<K, V> Map<K, V> cloneMap(Map<K, V> originalmap)
{
Gson gson = new Gson();
String jsonString = gson.toJson(originalmap);
return gson.fromJson(jsonString, Map.class);
}
//driver code
public static void main(String args[])
{
//creating an instance of the Map    
Map<String, Integer> hashMap = new HashMap();
//adding key-value pair to the Map
hashMap.put("Java", 7);
hashMap.put("Python", 2);
hashMap.put("C++", 9);
hashMap.put("COBOL", 12);
hashMap.put("C#", 4);
hashMap.put("Kotlin", 4);
Map<String, Integer> copy = clonemap(hashMap);
//prints the key-value pair
System.out.println(copy);
}
}

Output:

{Java=7, Python=2, C++=9, COBOL=12, C#=4, Kotlin=4}

Using HashMap.clone() Method

Java HashMap class provides the clone() method that returns a shallow copy of the HashMap instance. Note that keys and values are not cloned. The clone() method of the HashMap class overrides the clone() method of the AbstractMap<K, V>.

Syntax:

Example of HashMap.clone() Method

CloneHashMapExample6.java

import java.util.*;
public class CloneHashMapExample6
{
// Main driver method
public static void main(String args[])
{
// Creating an empty HashMap
HashMap<Integer, String> hashmap = new HashMap<Integer, String>();
//mapping string values to int keys
//using put() method
//custom input values passed as arguments
hashmap.put(13, "Blue Barriers");
hashmap.put(22, "Grapes");
hashmap.put(50, "Papaya");
hashmap.put(90, "Pineapple");
hashmap.put(110, "Apple");
//print and display the HashMap
System.out.println("Initial Mappings are: "+ hashmap);
//print and display the cloned HashMap
//using clone() method
System.out.println("The cloned map looks like this: "+ hashmap.clone());
}
}

Output:

Initial Mappings are: {50=Papaya, 22=Grapes, 90=Pineapple, 13=Blue Barriers, 110=Apple}
The cloned map looks like this: {50=Papaya, 90=Pineapple, 13=Blue Barriers, 22=Grapes, 110=Apple}

Next TopicFibodiv Number in Java

← prev next →