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:
| Method | Description |
|---|---|
| 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 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(); }} |
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
