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 APIimport 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 given // 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 given 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 associated : " + 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 associated : null Replace key 3 oldvalue of Akshat and newvalue Pari :true The Size of the ConcurrentHashMap is 5 The ConcurrentHashMap is empty
