Programa Java para implementar la API ConcurrentHashMap

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