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 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 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" );
}
} |
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