Java中的ConcurrentSkipListMap（附例子）

ConcurrentSkipListMap类 是Java Collections框架的一个成员，它在JDK 1.6中被引入，属于 java.util.concurrent 包。ConcurrentSkipListMap是ConcurrentNavigableMap的可伸缩实现。所有元素都是基于自然排序或构建时传递的比较器进行排序的。该类使用SkipList数据结构的并发变体，提供插入、删除、更新和访问操作的 log(n) 时间成本。这些操作可由多个线程同时执行，并且是安全的。

声明

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

在这里， K 是键对象类型， V 是值对象类型。

ConcurrentSkipListMap的层次结构

它实现了 Serializable ， Cloneable ， ConcurrentMap<K，V>， ConcurrentNavigableMap<K，V>， Map<K，V>， NavigableMap<K，V>， SortedMap<K，V> 接口，并扩展了 AbstractMap <K，V>类。

ConcurrentSkipListMap的构造函数

1. ConcurrentSkipListMap() : 构造一个新的、空的、按键的自然排序排序的映射。

ConcurrentSkipListMap<K, V> cslm = new ConcurrentSkipListMap<K, V>();

**2. ConcurrentSkipListMap​(Comparator <? super K> comparator) ** : 构造一个新的、空的、根据指定比较器排序的映射。

ConcurrentSkipListMap<K, V> cslm = new ConcurrentSkipListMap​<K, V>(Comparator<? super K> comparator);

**3. ConcurrentSkipListMap​(Map <? extends K,​? extends V> m) ** : 构造一个新的映射，其中包含与给定映射相同的映射关系，并按键的自然排序进行排序。

ConcurrentSkipListMap<K, V> cslm = new ConcurrentSkipListMap<K, V>​(Map<? extends K,​? extends V> m);

**4. ConcurrentSkipListMap​(SortedMap <K,​? extends V> m) ** : 构造一个新的映射，其中包含与指定排序映射相同的映射关系。

ConcurrentSkipListMap​<K, V> cslm = new ConcurrentSkipListMap​<K, V>(SortedMap<K,​? extends V> m);

示例

// Java程序演示
// ConcurrentSkipListMap
  
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
  
class ConcurrentSkipListMapExample {
    public static void main(String[] args)
    {
        // 创建ConcurrentSkipListMap实例
        ConcurrentSkipListMap<String, String> cslm
            = new ConcurrentSkipListMap<String, String>();
  
        // 使用put方法添加映射关系
        cslm.put("3", "Geeks");
        cslm.put("2", "from");
        cslm.put("1", "Hi!");
        cslm.put("5", "Geeks");
        cslm.put("4", "for");
  
        // 打印到控制台
        System.out.println("初始化Map : " + cslm);
  
        // 打印键为大于2的键值对
        System.out.println("ceilingEntry-2: "
                           + cslm.ceilingEntry("2"));
  
        // 获取键集的倒序
        NavigableSet navigableSet = cslm.descendingKeySet();
  
        System.out.println("descendingKeySet: ");
  
        // 遍历键集
        Iterator itr = navigableSet.iterator();
        while (itr.hasNext()) {
            String s = (String)itr.next();
            System.out.println(s);
        }
  
        // 打印第一个映射
        System.out.println("firstEntry: "
                           + cslm.firstEntry());
  
        // 打印最后一个映射
        System.out.println("lastEntry: "
                           + cslm.lastEntry());
  
        // 移除第一个映射并打印
        System.out.println("pollFirstEntry: "
                           + cslm.pollFirstEntry());
  
        // 打印第一个映射
        System.out.println("现在的第一个映射: "
                           + cslm.firstEntry());
  
        // 移除最后一个映射并打印
        System.out.println("pollLastEntry: "
                           + cslm.pollLastEntry());
  
        // 打印最后一个映射
        System.out.println("现在的最后一个映射: "
                           + cslm.lastEntry());
    }
}

输出

初始化Map : {1=Hi!, 2=from, 3=Geeks, 4=for, 5=Geeks}
ceilingEntry-2: 2=from
descendingKeySet: 
5
4
3
2
1
firstEntry: 1=Hi!
lastEntry: 5=Geeks
pollFirstEntry: 1=Hi!
现在的第一个映射: 2=from
pollLastEntry: 5=Geeks
现在的最后一个映射: 4=for

基本操作

1. 添加映射

ConcurrentSkipListMap的put()方法将指定值与指定键在该Map中关联。如果Map先前包含该键的映射，则旧值将被替换。

// Java程序演示添加
// ConcurrentSkipListMap中的映射
  
import java.util.concurrent.*;
  
class AddingMappingsExample {
    public static void main(String[] args)
    {
  
        // 初始化Map
        ConcurrentSkipListMap<Integer, Integer> cslm
            = new ConcurrentSkipListMap<Integer, Integer>();
  
        // 向该Map添加元素
        for (int i = 1; i <= 9; i++)
            cslm.put(i, i);
  
        // 对Map进行put()操作
        System.out.println("在put()之后: " + cslm);
    }
}

输出

在put()之后: {1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9}

2. 移除映射

ConcurrentSkipListMap的remove()方法从该Map中删除指定键的映射。如果该键没有映射，则返回null。执行该方法后，Map的大小会减小。要删除Map的第一个和最后一个条目，我们可以使用 pollFirstEntry() 和 pollLastEntry() 。

// Java Program Demonstrate removing
// mappings from ConcurrentSkipListMap
  
import java.util.concurrent.*;
  
class RemovingMappingsExample {
    public static void main(String[] args)
    {
  
        // 初始化映射表
        ConcurrentSkipListMap<Integer, Integer> cslm
            = new ConcurrentSkipListMap<Integer, Integer>();
  
        // 向映射表中添加元素
        for (int i = 1; i <= 6; i++)
            cslm.put(i, i);
  
        // 移除映射表中的元素
        cslm.remove(5);
  
        // 打印修改后的映射表
        System.out.println("After remove(): " + cslm);
  
        // 移除映射表中第一个映射并打印
        System.out.println("pollFirstEntry: "
                           + cslm.pollFirstEntry());
  
        // 移除映射表中最后一个映射并打印
        System.out.println("pollLastEntry: "
                           + cslm.pollLastEntry());
            
          // 打印最终映射表
          System.out.println("map contents: " + cslm);
    }
}

输出

After remove(): {1=1, 2=2, 3=3, 4=4, 6=6}
pollFirstEntry: 1=1
pollLastEntry: 6=6
map contents: {2=2, 3=3, 4=4}

3. 迭代

我们可以使用迭代器接口遍历集合框架中的任何结构。由于迭代器使用一种类型的数据，我们使用Entry< ? , ? >将两种单独的类型解析为兼容的格式。然后使用next()方法打印ConcurrentSkipListMap的元素。

// Java Program to demonstrate iterating
// over ConcurrentSkipListMap
  
import java.util.concurrent.*;
import java.util.*;
  
class IteratingExample {
    public static void main(String[] args)
    {
        // 创建ConcurrentSkipListMap的实例
        ConcurrentSkipListMap<Integer, Integer> cslm
            = new ConcurrentSkipListMap<>();
  
        // 使用put方法添加映射
        for (int i = 0; i < 6; i++) {
            cslm.put(i, i);
        }
  
        // 创建一个ConcurrentSkipListMap上的迭代器
        Iterator<ConcurrentSkipListMap
                     .Entry<Integer, Integer> > itr
            = cslm.entrySet().iterator();
  
        // hasNext()方法用于检查是否有下一个元素，next()方法用于检索下一个元素
        while (itr.hasNext()) {
            ConcurrentSkipListMap
                .Entry<Integer, Integer> entry
                = itr.next();
            System.out.println("Key = " + entry.getKey()
                               + ", Value = "
                               + entry.getValue());
        }
    }
}

输出

Key = 0, Value = 0
Key = 1, Value = 1
Key = 2, Value = 2
Key = 3, Value = 3
Key = 4, Value = 4
Key = 5, Value = 5

ConcurrentSkipListMap的方法

在类java.util.AbstractMap中声明的方法

在接口java.util.concurrent.ConcurrentMap中声明的方法

在接口java.util.concurrent.ConcurrentNavigableMap中声明的方法

在接口java.util.Map中声明的方法

在接口java.util.SortedMap中声明的方法

参考： https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentSkipListMap.html