Java程序实现ConcurrentSkipListMap API

ConcurrentSkipListMap API是基于ConcurrentNavigableMap的实现。这个地图是根据其键的自然排序或在创建时在地图上提供的比较器来排序的。这个类实现了SkipLists的一个并发变体，使得它在containsKey、get、put、remove操作及其变体上的预期平均时间成本为log（n）。

这个类和它的视图和迭代器实现了Map和Iterator接口的所有可选方法。像大多数其他并发集合一样，这个API不允许使用空键或空值。它是Java集合框架的一个成员。

所有实现的接口。

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

语法:

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

构造函数:

ConcurrentSkipListMap() – 创建一个新的、空的地图，根据键的自然顺序进行排序。
ConcurrentSkipListMap(Comparator<? super K> c) – 创建一个新的、根据给定的比较器排序的空地图。
ConcurrentSkipListMap(Map<? extends K,? extends V> mp) – 创建一个与给定地图相同的新地图，按照键的自然顺序排序。
ConcurrentSkipListMap(SortedMap<K,? extends V> mp) – 创建一个新的地图，其映射与给定的地图相同，并且是按照给定的排序地图进行排序。

方法:

方法	描述
ceilingEntry(K key)	该方法返回一个与最小键相关的键值对，大于或等于指定键，否则为空。
ceilingKey(K key)	该方法返回大于或等于指定键的最小键，否则为空。
clear()	这个方法从地图中删除所有的键值对
clone()	该方法返回ConcurrentSkipListMap实例的一个副本。
comparator()	该方法返回用于对地图中的键进行排序的比较器，否则如果使用键的自然排序则为空。
containsKey(Object key)	如果地图包含给定键的键值对，该方法返回true。
containsValue(Object value)	如果该地图为指定的值映射了一个或多个键，该方法返回true。
descendingKeySet()	该方法返回地图的键值的反向顺序NavigableSet视图。
descendingMap()	该方法返回地图中包含的键值对的反向顺序视图。
entrySet()	该方法返回地图中包含的键值对的集合视图。
equals(Object o)	该方法将给定的对象与地图进行平等比较。
firstEntry()	该方法返回一个与地图中最小的键相关的键值对。
firstKey()	该方法返回地图中的第一个（最低）键
floorEntry(K key)	该方法返回一个与小于或等于给定键的最大键相关的键值映射，否则为空。
get(Object key)	该方法返回指定键所映射的值，否则为空。
isEmpty()	如果地图中不包含键值对，该方法返回true
keySet()	该方法返回该地图中包含的键的NavigableSet视图。
lastEntry()	该方法返回一个与地图中最大键相关的键值对，如果地图是空的，则返回空值。
lastKey()	该方法返回当前地图中的最后一个（最高）键。
headMap(K toKey)	该方法返回地图中键值小于toKey的部分的视图。
lowerKey(K key)	该方法返回严格小于给定键的最大键，如果没有这样的键，则返回空。
size()	该方法返回map中键值对的数量
tailMap(K fromKey)	该方法返回地图中键值大于或等于fromKey的部分的视图。
values()	该方法返回地图中数值的集合视图
remove(Object key)	该方法从地图中删除指定键的映射。
put(K key, V value)	该方法将给定的值与地图中给定的键联系起来。
replace(K key, V value)	如果给定的键被映射为其他值，该方法将用指定的值替换给定的键的值。

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

输出:

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