Java Program to Implement ConcurrentSkipListMap API

import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableSet;
import java.util.Set;
import java.util.SortedMap;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

public class ConcurrentSkipList<K, V> {
    private ConcurrentSkipListMap<K, V> cmp;

    // Creates a new empty map sorted according to the
    // natural ordering of the keys
    public ConcurrentSkipList()
    {
        cmp = new ConcurrentSkipListMap<K, V>();
    }

    // Creates a new empty map sorted according to the given
    // comparator
    public ConcurrentSkipList(Comparator<? super K> comp)
    {
        cmp = new ConcurrentSkipListMap<K, V>(comp);
    }

    // Creates a new map with the same key-value pairs as
    // the specified map and sorted according to the natural
    // ordering of the keys.
    public ConcurrentSkipList(
        Map<? extends K, ? extends V> mp)
    {
        cmp = new ConcurrentSkipListMap<K, V>(mp);
    }

    // Creates a new map containing the same key-value pairs
    // and same ordering as the specified map.
    public ConcurrentSkipList(SortedMap<K, ? extends V> mp)
    {
        cmp = new ConcurrentSkipListMap<K, V>(mp);
    }

    // Returns a mapping associated with the least key
    // greater than or equal to the specified key or
    // otherwise null
    public Map.Entry<K, V> ceilingEntry(K k)
    {
        return cmp.ceilingEntry(k);
    }

    // Returns the least key greater than or equal to the
    // specified key or otherwise null
    public K ceilingKey(K k) { return cmp.ceilingKey(k); }

    // Removes all the key-value pairs of the map
    public void clear() { cmp.clear(); }

    // Returns a copy of the ConcurrentSkipListMap
    public ConcurrentSkipListMap<K, V> clone()
    {
        return cmp.clone();
    }

    // Returns the comparator used for ordering the keys in
    // the map
    public Comparator<? super K> comparator()
    {
        return cmp.comparator();
    }

    // Returns true if the map contains the specified key.
    public boolean containsKey(Object k)
    {
        return cmp.containsKey(k);
    }

    // Returns true if the map contains one or more keys
    // mapped to the given value
    public boolean containsValue(Object v)
    {
        return cmp.containsValue(v);
    }

    // Returns a reverse order NavigableSet view of the keys
    // in the map
    public NavigableSet<K> descendingKeySet()
    {
        return cmp.descendingKeySet();
    }

    // Returns a reverse order view of the key-value pairs
    // in the map.
    public ConcurrentNavigableMap<K, V> descendingMap()
    {
        return cmp.descendingMap();
    }

    // Returns a Set view of the key-value pairs in the map
    public Set<Map.Entry<K, V> > entrySet()
    {
        return cmp.entrySet();
    }

    // Returns the mapping that is associated with the least
    // key in the map or otherwise null
    public Map.Entry<K, V> firstEntry()
    {
        return cmp.firstEntry();
    }

    // Returns the first (lowest) key in the map.
    public K firstKey() { return cmp.firstKey(); }

    // Returns the greatest key less than or equal to the
    // specified key or otherwise null
    public K floorKey(K k) { return cmp.floorKey(k); }

    // Returns the value to which the given key is mapped
    public V get(Object k) { return cmp.get(k); }

    // Returns a portion of the map whose keys are strictly
    // less than k
    public ConcurrentNavigableMap<K, V> headMap(K k)
    {
        return cmp.headMap(k);
    }

    // Returns a portion of the map whose keys are strictly
    // less than or equal to k
    public ConcurrentNavigableMap<K, V> headMap(K k,
                                                boolean in)
    {
        return cmp.headMap(k, in);
    }

    // Returns a mapping that is associated with the least
    // key strictly greater than the specified key or
    // otherwise null
    public Map.Entry<K, V> higherEntry(K k)
    {
        return cmp.higherEntry(k);
    }

    // Returns the least key strictly greater than the given
    // key, or otherwise null.
    public K higherKey(K k) { return cmp.higherKey(k); }

    // Returs the set view of the keys in the map
    public Set<K> keySet() { return cmp.keySet(); }

    // Returns a mapping associated with the greatest key in
    // the map, or otherwise null.
    public Map.Entry<K, V> lastEntry()
    {
        return cmp.lastEntry();
    }

    // Returns the last(highest) key in the map.
    public K lastKey() { return cmp.lastKey(); }

    // Returns a mapping that is associated with the
    // greatest key strictly less than the specified key or
    // otherwise null
    public Map.Entry<K, V> lowerEntry(K k)
    {
        return cmp.lowerEntry(k);
    }

    // Returns the greatest key strictly less than the given
    // key or otherwise null
    public K lowerKey(K k) { return cmp.lowerKey(k); }

    // Returns a NavigableSet view of the keys in the map.
    public NavigableSet<K> navigableKeySet()
    {
        return cmp.navigableKeySet();
    }

    // Removes and returns a mapping associated with the
    // least key in the map, or otherwise null
    public Map.Entry<K, V> pollFirstEntry()
    {
        return cmp.pollFirstEntry();
    }

    // Removes and returns a  mapping associated with the
    // greatest key
    // in the map, or otherwise null
    public Map.Entry<K, V> pollLastEntry()
    {
        return cmp.pollLastEntry();
    }

    // Maps the given value to the given key in the map
    public V put(K k, V v) { return cmp.put(k, v); }

    // Copies all the key-value pairs of the given map to
    // the ConcurrentSkipListMap
    public void putAll(Map<? extends K, ? extends V> mp)
    {
        cmp.putAll(mp);
    }

    // Removes the mapping of the given key from the map
    public V remove(Object k) { return cmp.remove(k); }

    // Replaces the given key with the given value if the
    // key is already mapped
    public V replace(K k, V v) { return cmp.replace(k, v); }

    // Replaces the given key with the given value if the
    // key is already mapped
    public boolean replace(K k, V oValue, V nValue)
    {
        return cmp.replace(k, oValue, nValue);
    }

    // Returns the number of mapping in the map
    public int size() { return cmp.size(); }

    // Return a portion of the map whose keys are from k1 to
    // k2
    public ConcurrentNavigableMap<K, V>
    subMap(K k1, boolean f, K k2, boolean t)
    {
        return cmp.subMap(k1, f, k2, t);
    }

    // Returns a portion of the map whose keys are from
    // k1(inclusive) to k2(exclusive)
    public ConcurrentNavigableMap<K, V> subMap(K k1, K k2)
    {
        return cmp.subMap(k1, k2);
    }

    // Returns a Collection view of the values of the map
    public Collection<V> values() { return cmp.values(); }

    public static void main(String[] arg)
    {
        ConcurrentSkipList<Integer, String> cmp
            = new ConcurrentSkipList<Integer, String>();
        cmp.put(1, "Sahil");
        cmp.put(2, "Kahish");
        cmp.put(3, "Tarun");
        cmp.put(4, "Karan");
        Map<Integer, String> mp
            = new HashMap<Integer, String>();
        mp.put(5, "Shweta");
        mp.put(6, "Aditya");
        cmp.putAll(mp);

        System.out.println("The key set of the map is ");
        Set<Integer> kSet = cmp.keySet();
        Iterator<Integer> i = kSet.iterator();
        while (i.hasNext()) {
            System.out.print(i.next() + " ");
        }
        System.out.println();
        System.out.println("The values of the Map is ");
        Collection<String> values = cmp.values();
        Iterator<String> it = values.iterator();
        it = values.iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println();
        System.out.println(
            "Poll first entry of the ConcurrentSkipListMap ");
        Map.Entry<Integer, String> pfe
            = cmp.pollFirstEntry();
        System.out.println("Key = " + pfe.getKey()
                           + " Value = " + pfe.getValue());
        System.out.println(
            "Poll last entry of the ConcurrentSkipListMap ");
        Map.Entry<Integer, String> ple
            = cmp.pollLastEntry();
        System.out.println("key = " + ple.getKey()
                           + " value = " + ple.getValue());
        System.out.println("The entry set of the map is ");
        Iterator<Entry<Integer, String> > itr;
        Set<Entry<Integer, String> > eSet = cmp.entrySet();
        itr = eSet.iterator();
        while (itr.hasNext()) {
            System.out.println(itr.next() + " ");
        }
        System.out.println(
            "The concurrentSkipListMap contains Key 4 :"
            + cmp.containsKey(4));
        System.out.println(
            "The  concurrentSkipListMap contains Value 9 :"
            + cmp.containsValue(9));
        System.out.println(
            "The size of the concurrentSkipListMap is "
            + cmp.size());
        cmp.clear();
    }
}