The putAll() method in Java’s ConcurrentHashMap class is used to copy all the key-value mappings from a specified map to the current map. It has the following signature:
void putAll(Map<? extends K,? extends V> m)
where:
m is the map whose key-value mappings are to be copied to the current map.
The putAll() method works in a concurrent environment, which means that it can be called from multiple threads without causing any data race or synchronization issues.
When a putAll() operation is performed, the method first acquires the lock on all the segments of the current map and then copies all the key-value mappings from the specified map to the current map.
Here is an example of using the putAll() method:
Java
import java.util.concurrent.ConcurrentHashMap;
import java.util.HashMap;
import java.util.Map;
public class ConcurrentHashMapExample {
public static void main(String[] args) {
ConcurrentHashMap<String, Integer> map1 = new ConcurrentHashMap<>();
map1.put( "Alice" , 25 );
map1.put( "Bob" , 30 );
Map<String, Integer> map2 = new HashMap<>();
map2.put( "Charlie" , 35 );
map2.put( "Dave" , 40 );
map1.putAll(map2);
System.out.println( "Combined map: " + map1);
}
}
|
Output
Combined map: {Bob=30, Alice=25, Charlie=35, Dave=40}
The java.util.concurrent.ConcurrentHashMap.putAll() is an in-built function in Java that is used for the copy operation. The method copies all of the elements i.e., the mappings, from one ConcurrentHashMap into another.
Syntax:
new_conn_hash_map.putAll(conn_hash_map)
Parameters: The function accepts a ConcurrentHashMap conn_hash_map as its only parameter and copies all its mappings with this map.
Return Value: The method does not return any values.
Exception: The function throws NullPointerException when the specified parameter is null. Below programs illustrate the ConcurrentHashMap.putAll() method :
Program 1: This program involves mapping String Values to Integer Keys.
Java
import java.util.concurrent.*;
class ConcurrentHashMapDemo {
public static void main(String[] args)
{
ConcurrentHashMap<Integer, String> chm
= new ConcurrentHashMap<Integer, String>();
chm.put( 100 , "Geeks" );
chm.put( 101 , "for" );
chm.put( 102 , "Geeks" );
chm.put( 103 , "Gfg" );
chm.put( 104 , "GFG" );
System.out.println( "Initial Mappings are: " + chm);
ConcurrentHashMap<Integer, String> new_chm
= new ConcurrentHashMap<Integer, String>();
new_chm.putAll(chm);
System.out.println( "New mappings are: " + new_chm);
}
}
|
Output
Initial Mappings are: {100=Geeks, 101=for, 102=Geeks, 103=Gfg, 104=GFG}
New mappings are: {100=Geeks, 101=for, 102=Geeks, 103=Gfg, 104=GFG}
Program 2: This program involves mapping Integer Values to String Keys.
Java
import java.util.concurrent.*;
class ConcurrentHashMapDemo {
public static void main(String[] args)
{
ConcurrentHashMap<String, Integer> chm
= new ConcurrentHashMap<String, Integer>();
chm.put( "Gfg" , 100 );
chm.put( "GFG" , 102 );
chm.put( "GfG" , 18 );
chm.put( "gfg" , 15 );
chm.put( "gfG" , 55 );
System.out.println( "Initial Mappings are: " + chm);
ConcurrentHashMap<String, Integer> new_chm
= new ConcurrentHashMap<String, Integer>();
new_chm.putAll(chm);
new_chm.put( "gFg" , 22 );
System.out.println( "New mappings are: " + new_chm);
}
}
|
Output
Initial Mappings are: {Gfg=100, GFG=102, GfG=18, gfg=15, gfG=55}
New mappings are: {Gfg=100, GFG=102, GfG=18, gfg=15, gfG=55, gFg=22}
Feeling lost in the vast world of Backend Development? It's time for a change! Join our
Java Backend Development - Live Course and embark on an exciting journey to master backend development efficiently and on schedule.
What We Offer:
- Comprehensive Course
- Expert Guidance for Efficient Learning
- Hands-on Experience with Real-world Projects
- Proven Track Record with 100,000+ Successful Geeks
Last Updated :
20 Feb, 2023
Like Article
Save Article