Skip to content
Related Articles

Related Articles

Java Program to Implement ConcurrentHashMap API
  • Last Updated : 22 Feb, 2021

ConcurrentHashMap class obeys the same functional specification as HashTable and includes all the versions of methods corresponding to each method of a HashTable. A HashTable supports the full concurrency of retrievals and adjustable concurrency for updates. All the operations of ConcurrentHashMap are thread-safe but the retrieval operations do not entail locking i.e. it does not support locking the entire table in a way that prevents all access. This API is fully interoperable to the HashTable in the programs. It is present in java.util.concurrent package.

ConcurrentHashMap extends AbstractMap<K,V> and Object classes. This API does not allow null to be used as a key or value and it is a member of Java Collections Framework.

Type Parameters:

  • K – the type of keys maintained by the map
  • V – the type of values mapped to it.

All implemented interfaces:

Serializable, ConcurrentMap<K,V>, Map<K,V>

Syntax:



public class ConcurrentHashMap<K,V>
extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable

Constructors:

  • ConcurrentHashMap() – Creates an empty Map with an initial capacity of 16, load factor of 0.75 and concurrency level of 16.
  • ConcurrentHashMap(int initialCapacity) – Creates an empty Map with the given initial capacity and default values of load factor and concurrencyLevel.
  • ConcurrentHashMap(int initialCapacity, float loadFactor) – Creates an empty Map with the given initial capacity and given load factor and default concurrencyLevel.
  • ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) – Creates an empty Map with given initial capacity, load factor and concurrencyLevel.
  • ConcurrentHashMap(Map<? extends K,? extends V> m) – Creates a new Map with the same mappings as given in the Map.

Code:

Java




// Java Program to Implement ConcurrentHashMap API
  
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
  
public class ConcurrentMap<K, V> {
    private ConcurrentHashMap<K, V> hm;
  
    // creates an empty ConcurrentHashMap with initial
    // capacity 16 and load factor 0.75
    public ConcurrentMap()
    {
        hm = new ConcurrentHashMap<K, V>();
    }
  
    // creates an empty ConcurrentHashMap with given initial
    // capacity and load factor 0.75
    public ConcurrentMap(int incap)
    {
        hm = new ConcurrentHashMap<K, V>(incap);
    }
  
    // creates an empty ConcurrentHashMap with given initial
    // capacity and load factor
    public ConcurrentMap(int incap, float lf)
    {
        hm = new ConcurrentHashMap<K, V>(incap, lf);
    }
  
    // creates an empty ConcurrentHashMap with given initial
    // capacity, load factor and concurrency level
    public ConcurrentMap(int incap, float lf,
                         int concurrLevel)
    {
        hm = new ConcurrentHashMap<K, V>(incap, lf,
                                         concurrLevel);
    }
  
    // Creates an hashMap with the same values as the gievn
    // hashMap
    public ConcurrentMap(Map<? extends K, ? extends V> m)
    {
        hm = new ConcurrentHashMap<K, V>(m);
    }
  
    // Removes all the keys and values from the Map
    public void clear() { hm.clear(); }
  
    // Return true if the Map contains the given Key
    public boolean containsKey(Object k)
    {
        return hm.containsKey(k);
    }
  
    // Return true if the map contains keys that maps to the
    // given value
    public boolean containsValue(Object v)
    {
        return hm.containsValue(v);
    }
  
    // Returns a set view of the key-value pairs of the map
    public Set<Map.Entry<K, V> > entrySet()
    {
        return hm.entrySet();
    }
  
    // Return the value to which the given key is mapped
    public V get(Object k) { return hm.get(k); }
  
    // Return true if the map does not contains any
    // key-value pairs
    public boolean isEmpty() { return hm.isEmpty(); }
  
    // Returns a set view of the key-value pairs of the map
    public Set<K> keySet() { return hm.keySet(); }
  
    // Maps the given value to the given key in the map
    public V put(K k, V v) { return hm.put(k, v); }
  
    // Copies all the key-value pairs from one map to
    // another
    public void putAll(Map<? extends K, ? extends V> mp)
    {
        hm.putAll(mp);
    }
  
    // Removes the mapping of the given key from its value
    public V remove(Object k) { return hm.remove(k); }
  
    // Returns the size of the map
    public int size() { return hm.size(); }
  
    // Returns the collection view of the values of the map
    public Collection<V> values() { return hm.values(); }
  
    // Returns an enumeration of the gievn values of the map
    public Enumeration<V> elements()
    {
        return hm.elements();
    }
  
    // If the given key is not associated with the given
    // value then associate it.
    public V putIfAbsent(K k, V v)
    {
        return hm.putIfAbsent(k, v);
    }
  
    // Replaces the value for a key only if it is currently
    // mapped to some value.
    public V replace(K key, V value)
    {
        return hm.replace(key, value);
    }
  
    // Replaces the oldValue for a key only if it is
    // currently mapped to a given value. *
    public boolean replace(K key, V oValue, V nValue)
    {
        return hm.replace(key, oValue, nValue);
    }
  
    public static void main(String[] arg)
    {
        // Creating an object of the class
        ConcurrentMap<Integer, String> hm
            = new ConcurrentMap<Integer, String>();
  
        hm.put(1, "Amit");
        hm.put(2, "Ankush");
        hm.put(3, "Akshat");
        hm.put(4, "Tarun");
  
        // Creating another Map
        Map<Integer, String> hm2 = new HashMap<Integer, String>();
        hm.putAll(hm2);
  
        System.out.println("The Keys of the ConcurrentHashMap is ");
        
        Set<Integer> k = hm.keySet();
        Iterator<Integer> i = k.iterator();
        
        while (i.hasNext()) 
        {
            System.out.print(i.next() + " ");
        }
        System.out.println();
        
        System.out.println("The values of the ConcurrentHashMap is ");
        
        Collection<String> values = hm.values();
        Iterator<String> s = values.iterator();
        
        while (s.hasNext()) 
        {
            System.out.print(s.next() + " ");
        }
        System.out.println();
        
        System.out.println("The entry set of the ConcurrentHashMap is ");
        
        Iterator<Entry<Integer, String> > er;
        Set<Entry<Integer, String> > ent = hm.entrySet();
        
        er = ent.iterator();
        
        while (er.hasNext()) 
        {
            System.out.println(er.next() + " ");
        }
        
        System.out.println("The ConcurrentHashMap contains Key 3 :"
            + hm.containsKey(3));
        
        System.out.println("The ConcurrentHashMap contains Tarun:"
            + hm.containsValue("Tarun"));
        
        System.out.println("Put the key 10 with value Shikha  if not asscociated : "
            + hm.putIfAbsent(10, "Shikha"));
        
        System.out.println("Replace key 3 oldvalue of Akshat and newvalue Pari :"
            + hm.replace(3, "Akshat", "Pari"));
        
        System.out.println("The Size of the ConcurrentHashMap is "
            + hm.size());
        
        // Clearing the Concurrent map
        hm.clear();
        
        if (hm.isEmpty())
            System.out.println("The ConcurrentHashMap is empty");
        else
            System.out.println("The ConcurrentHashMap is not empty");
    }
}
Output
The Keys of the ConcurrentHashMap is 
1 2 3 4 
The values of the ConcurrentHashMap is 
Amit Ankush Akshat Tarun 
The entry set of the ConcurrentHashMap is 
1=Amit 
2=Ankush 
3=Akshat 
4=Tarun 
The ConcurrentHashMap contains Key 3 :true
The ConcurrentHashMap contains Tarun:true
Put the key 10 with value Shikha  if not asscociated : null
Replace key 3 oldvalue of Akshat and newvalue Pari :true
The Size of the ConcurrentHashMap is 5
The ConcurrentHashMap is empty

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :