Skip to content
Related Articles

Related Articles

Improve Article
Java Program to Implement ConcurrentSkipListMap API
  • Last Updated : 09 Mar, 2021

ConcurrentSkipListMap API is based on the implementation of the ConcurrentNavigableMap. This map is sorted according to the natural ordering of its keys or by a Comparator provided on the map during creation time. This class implements a concurrent variant of SkipLists which makes its expected average time cost of log(n) for containsKey, get, put, remove operations and their variants.

This class and its views and iterators implement all the optional methods of the Map and Iterator interfaces. Like most other concurrent collections, this API does not permit the use of null keys or values. It is a member of the Java Collections Framework.

All implemented interfaces:

Serializable, Cloneable, ConcurrentMap<K,V>, ConcurrentNavigableMap<K,V>, Map<K,V>, 
NavigableMap<K,V>, SortedMap<K,V>

Syntax:

public class ConcurrentSkipListMap<K,V>
 extends AbstractMap<K,V>
implements ConcurrentNavigableMap<K,V>, Cloneable, Serializable

Constructors:



  • ConcurrentSkipListMap() – Creates a new, empty map, sorted according to the natural ordering of the keys.
  • ConcurrentSkipListMap(Comparator<? super K> c) – Creates a new, empty map sorted according to the given comparator.
  • ConcurrentSkipListMap(Map<? extends K,? extends V> mp) – Creates a new map with the same mapping as the given map , sorted according to the natural ordering of the keys.
  • ConcurrentSkipListMap(SortedMap<K,? extends V> mp) – Creates a new map with the same mappings as the given map and as the sorted according to the given sorted map.

Methods:

MethodDescription
ceilingEntry(K key)This method returns a key-value pair associated with the least key, greater than or equal to the specified key otherwise null.
ceilingKey(K key)This method returns the least key greater than or equal to the specified key otherwise null.
clear()This method removes all the key-value pairs from the map
clone()This method returns a copy of the ConcurrentSkipListMap instance.
comparator()This method returns the comparator used for the ordering of the keys in the map otherwise null if it uses the natural ordering for the keys.
containsKey(Object key)This method returns true if the map contains the key-value pair for the given key.
containsValue(Object value)This method returns true if the map maps one or more keys for the specified value.
descendingKeySet()This method returns a reverse order NavigableSet view of the keys of the map
descendingMap()This method returns the reverse order view of the key-value pairs contained in the map. 
entrySet()This method returns a set view of the key-value pairs contained in the map.
equals(Object o)This method compares the given object with the map for equality.
firstEntry()This method returns a key-value pair associated with the least key in the map.
firstKey()This method returns the first(lowest) key in the map
floorEntry(K key)This method returns a key-value mapping associated with the greatest key less than or equal to the given key or otherwise null
get(Object key)This method returns the value to which the specified key is mapped or otherwise null
isEmpty()This method returns true if the map contains no key-value pair in the map
keySet()This method returns a NavigableSet view of the keys contained in this map.
lastEntry()This method returns a key-value pair associated with the greatest key in the map or otherwise null if the map is empty
lastKey()This method returns the last (highest) key currently in the map.
headMap(K toKey)This method returns a view of the portion of the map whose keys are less than toKey.
lowerKey(K key)This method returns the greatest key strictly less than the given key, or null if there is no such key.
size()This method returns the number of key-value pairs in the map
tailMap(K fromKey)This method returns a view of the portion of the map whose keys are greater than or equal to fromKey.
values()This method returns a collection view of the values in the map
remove(Object key)This method removes the mapping for the specified key from the map.
put(K key, V value)This method associates the given value with the given key in the map.
replace(K key, V value)This method replaces the value of the given key with the specified value if it is mapped with some other value.

Java




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 gievn
    // 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();
    }
}

Output:

The key set of the map is 
1    2    3    4    5    6    
The values of the concurrentSkipListMap is 
Sahil    Kashish    Tarun    Karan    Shweta    Aditya    
Poll first entry of the ConcurrentSkipListMap 
key = 1 value = Sahil
Poll last entry of the ConcurrentSkipListMap
key = 6 value = Aditya
The entry set of the Map is 
2=Kashish    
3=Tarun    
4=Karan    
5=Shweta
The concurrentSkipListMap contains Key 4 :true
The  concurrentSkipListMap contains Value 9 :false
The size of the concurrentSkipListMap is 6

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 :