ConcurrentSkipListMap api详解

今天时间学习ConcurrentSkipListMap api，该类是JUC原子包中的类，通过单元测试代码把所有public api方法跑了一遍，大致了解了底层实现，初学乍练，有很多一知半解的地方，待后续有了深入理解再来补充

package test.java.util.concurrent; import java.util.*; import java.util.concurrent.ConcurrentNavigableMap; import java.util.concurrent.ConcurrentSkipListMap; import org.junit.Test; / * ConcurrentSkipListMap的测试类 * * @date 2020-07-08 20:15:37 */ public class ConcurrentSkipListMapTest { / *无参构造函数 * @Param */ @Test public void testConstruct0()throws Exception{ ConcurrentSkipListMap testObj=new ConcurrentSkipListMap(); System.out.println(testObj.toString()); } / * 初始化comparator比较器通过构造函数 * @Param */ @Test public void testConstruct1()throws Exception{ Comparator comparator=((o1, o2) -> Integer.parseInt(o1.toString())+Integer.parseInt(o2.toString())); ConcurrentSkipListMap testObj=new ConcurrentSkipListMap(comparator); System.out.println(testObj.toString()); } / *初始化skipMap，并将参数map中的键值对放入新的skipMap中 * @Param */ @Test public void testConstruct2()throws Exception{ Map map=new HashMap(); map.put(33,12); ConcurrentSkipListMap testObj=new ConcurrentSkipListMap(map); System.out.println(testObj.toString()); } / *通过sortedMap初始化ConcurrentSkipListMap，并将sortedmap中的元素放入新map * @Param */ @Test public void testConstruct3()throws Exception{ Map 
  
    sortedMap=new ConcurrentSkipListMap<>(); sortedMap.put(1,1); sortedMap.put(2,2); sortedMap.put(4,4); sortedMap.put(3,3); ConcurrentSkipListMap testObj=new ConcurrentSkipListMap(sortedMap); System.out.println(testObj.toString()); } / * 浅拷贝 * @Param */ @Test public void testClone()throws Exception{ Map map3=new ConcurrentSkipListMap<>(); map3.put(5,5); Map map1=new ConcurrentSkipListMap<>(); map1.put(1,1); map1.put(2,2); map1.put(,map3); map1.put(3,3); Map 
   
     map2=((ConcurrentSkipListMap 
    
      ) map1).clone(); System.out.println(map1.hashCode()); System.out.println(map2.hashCode()); map1.put(,333); System.out.println(map1.get()); System.out.println(map2.get()); } / *是否包含key，使用doGet(key) != null判断 * @Param */ @Test public void testContainsKey()throws Exception{ ConcurrentSkipListMap 
     
       map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.containsKey(1)); } / *通过key获取值 * @Param */ @Test public void testGet()throws Exception{ ConcurrentSkipListMap 
      
        map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.get(1)); } / * 通过key获取值，没有则返回给定默认值 * @Param */ @Test public void testGetOrDefault()throws Exception{ ConcurrentSkipListMap 
       
         map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.getOrDefault(7,8)); } / * 存入键值对 * @Param */ @Test public void testPut()throws Exception{ ConcurrentSkipListMap 
        
          map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.getOrDefault(7,8)); } / * 移除并返回key所对应的值 * @Param */ @Test public void testRemove1()throws Exception{ ConcurrentSkipListMap 
         
           map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.remove(3)); System.out.println(map.get(3)); } / * 是否包含指定value * @Param */ @Test public void testContainsValue()throws Exception{ ConcurrentSkipListMap 
          
            map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.containsValue(4)); } / * map中node数量 * @Param */ @Test public void testSize()throws Exception{ ConcurrentSkipListMap 
           
             map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.size()); } / *是否为空 * @Param */ @Test public void testIsEmpty()throws Exception{ ConcurrentSkipListMap 
            
              map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.isEmpty()); } / * 清空map * @Param */ @Test public void testClear()throws Exception{ ConcurrentSkipListMap 
             
               map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); map.clear(); System.out.println(map.isEmpty()); } / * 通过key计算，并返回计算结果 * @Param */ @Test public void testComputeIfAbsent()throws Exception{ ConcurrentSkipListMap 
              
                map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.computeIfAbsent(1,a -> a*2)); } / *将key和val传给BiFunction计算并返回结果 * @Param */ @Test public void testComputeIfPresent()throws Exception{ ConcurrentSkipListMap 
               
                 map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.computeIfPresent(1, ((key, val) -> key+val))); } / *将key和val传给BiFunction计算并返回结果 * @Param */ @Test public void testCompute()throws Exception{ ConcurrentSkipListMap 
                
                  map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.compute(1, ((key, val) -> key+val))); } / * 将参数一即key对应的map中的value值与参数二传入BiFunction计算，并将结果返回 * @Param */ @Test public void testMerge()throws Exception{ ConcurrentSkipListMap 
                 
                   map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.merge(3,3, ((key, val) -> key+val))); } / * 通过keySet遍历 * @Param */ @Test public void testKeySet()throws Exception{ ConcurrentSkipListMap 
                  
                    map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); NavigableSet 
                   
                     keySet=map.keySet(); System.out.println(keySet.lower(5)); Iterator 
                    
                      iterator=keySet.iterator(); while (iterator.hasNext()){ Integer key=iterator.next(); System.out.println(key+":"+map.get(key)); } } / * 与keySet方法一样效果 * @Param */ @Test public void testNavigableKeySet()throws Exception{ ConcurrentSkipListMap 
                     
                       map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); NavigableSet 
                      
                        keySet=map.navigableKeySet(); System.out.println(keySet.lower(5)); Iterator 
                       
                         iterator=keySet.iterator(); while (iterator.hasNext()){ Integer key=iterator.next(); System.out.println(key+":"+map.get(key)); } } / *遍历所有value * @Param */ @Test public void testValues()throws Exception{ ConcurrentSkipListMap 
                        
                          map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); Collection valCollection=map.values(); Iterator 
                         
                           iterator=valCollection.iterator(); while (iterator.hasNext()){ System.out.println(iterator.next()); } } / *通过entrySet遍历所有key和val * @Param */ @Test public void testEntrySet()throws Exception{ ConcurrentSkipListMap 
                          
                            map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); Set 
                           
                             > entrySet=map.entrySet(); Iterator 
                            
                              > iterator=entrySet.iterator(); while (iterator.hasNext()){ Map.Entry 
                             
                               entry=iterator.next(); System.out.println(entry.getKey()+":"+entry.getValue()); } } / *转换成ConcurrentNavigableMap * @Param */ @Test public void testDescendingMap()throws Exception{ ConcurrentSkipListMap 
                              
                                map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); ConcurrentNavigableMap navigableMap =map.descendingMap(); Set 
                               
                                 > nentrySet=navigableMap.entrySet(); Iterator 
                                
                                  > iterator=nentrySet.iterator(); while (iterator.hasNext()){ Map.Entry 
                                 
                                   entry=iterator.next(); System.out.println(entry.getKey()+":"+entry.getValue()); } } / * 内部先降级为navigableMap，再降级为navigableSet，即key的set集合 * @Param */ @Test public void testDescendingKeySet()throws Exception{ ConcurrentSkipListMap 
                                  
                                    map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); NavigableSet 
                                   
                                     navigableSet =map.descendingKeySet(); Iterator 
                                    
                                      iterator=navigableSet.iterator(); while (iterator.hasNext()){ Integer key=iterator.next(); System.out.println(key+":"+map.get(key)); } } / *是否相等 * @Param */ @Test public void testEquals()throws Exception{ ConcurrentSkipListMap 
                                     
                                       map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.equals(map)); } / *onlyIfAbsent 如果当前位置已存在一个值，是否替换，false是替换，true是不替换 * 默认true不替换 * @Param */ @Test public void testPutIfAbsent()throws Exception{ ConcurrentSkipListMap 
                                      
                                        map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.putIfAbsent(12,321)); System.out.println(map.get(12)); } / *通过键值对比对，删除，有一个不对则删除失败 * @Param */ @Test public void testRemove()throws Exception{ ConcurrentSkipListMap 
                                       
                                         map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.remove(1,2)); System.out.println(map.get(1)); } / *通过key替换原来的val，并返回原val * @Param */ @Test public void testReplace1()throws Exception{ ConcurrentSkipListMap 
                                        
                                          map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.replace(1,3332)); System.out.println(map.get(1)); } / * 通过key和val查找对应节点node，存在则将oldvalue替换为新的value，返回替换成功或失败 * @Param */ @Test public void testReplace()throws Exception{ ConcurrentSkipListMap 
                                         
                                           map=new ConcurrentSkipListMap<>(); map.put(1,2); map.put(3,4); map.put(5,6); System.out.println(map.replace(1,2,33)); System.out.println(map.get(1)); } / *通过comparator初始化map * @Param */ @Test public void testComparator()throws Exception{ Comparator comparator=((o1, o2) -> Integer.parseInt(o1.toString())+Integer.parseInt(o2.toString())); ConcurrentSkipListMap 
                                          
                                            map=new ConcurrentSkipListMap<>(comparator); map.put(1,2); map.put(3,4); map.put(5,6); Comparator comparator1=map.comparator(); System.out.println(comparator1.compare(1, 2)); } / *获取第一个key（排序过后的） * @Param */ @Test public void testFirstKey()throws Exception{ ConcurrentSkipListMap 
                                           
                                             map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(1,2); map.put(5,6); System.out.println(map.firstKey()); } / *获取最后一个key（排序过后的） * @Param */ @Test public void testLastKey()throws Exception{ ConcurrentSkipListMap 
                                            
                                              map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(1,2); System.out.println(map.lastKey()); } / *从参数一到参数3的所有键值map，fromInclusive是否包含起始值，toInclusive是否包含末尾值 * @Param */ @Test public void testSubMap1()throws Exception{ ConcurrentSkipListMap 
                                             
                                               map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(1,2); ConcurrentNavigableMap 
                                              
                                                concurrentNavigableMap=map.subMap(1,false,2,true); System.out.println(concurrentNavigableMap.get(1)); } / * 从开始到参数一的所有键值对，inclusive是否包含默认值 * @Param */ @Test public void testHeadMap1()throws Exception{ ConcurrentSkipListMap 
                                               
                                                 map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(1,2); ConcurrentNavigableMap 
                                                
                                                  concurrentNavigableMap=map.headMap(3,true); System.out.println(concurrentNavigableMap.get(3)); } / *从参数一到最后的所有键值对，inclusive是否包含默认值 * @Param */ @Test public void testTailMap1()throws Exception{ ConcurrentSkipListMap 
                                                 
                                                   map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(1,2); ConcurrentNavigableMap 
                                                  
                                                    concurrentNavigableMap=map.tailMap(3,false); System.out.println(concurrentNavigableMap.get(3)); } / *从参数一到参数2的所有键值map，默认包含起始值不包含结尾值 * @Param */ @Test public void testSubMap()throws Exception{ ConcurrentSkipListMap 
                                                   
                                                     map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(1,2); ConcurrentNavigableMap 
                                                    
                                                      concurrentNavigableMap=map.subMap(3,5); System.out.println(concurrentNavigableMap.get(5)); } / *从开始到参数一的所有键值对，默认不包含结尾值 * @Param */ @Test public void testHeadMap()throws Exception{ ConcurrentSkipListMap 
                                                     
                                                       map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(1,2); ConcurrentNavigableMap 
                                                      
                                                        concurrentNavigableMap=map.headMap(3); System.out.println(concurrentNavigableMap.get(3)); } / *从参数一到最后的所有键值对，默认包含起始值 * @Param */ @Test public void testTailMap()throws Exception{ ConcurrentSkipListMap 
                                                       
                                                         map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(1,2); ConcurrentNavigableMap 
                                                        
                                                          concurrentNavigableMap=map.tailMap(3); System.out.println(concurrentNavigableMap.get(3)); } / *获取比指定key小的第一个entry * @Param */ @Test public void testLowerEntry()throws Exception{ ConcurrentSkipListMap 
                                                         
                                                           map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(1,2); System.out.println(map.lowerEntry(5).getValue()); } / *获取比指定key小的第一个key * @Param */ @Test public void testLowerKey()throws Exception{ ConcurrentSkipListMap 
                                                          
                                                            map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(1,2); System.out.println(map.lowerKey(5)); } / *获取离给定key最近的entry对象 * @Param */ @Test public void testFloorEntry()throws Exception{ ConcurrentSkipListMap 
                                                           
                                                             map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(1,2); System.out.println(map.floorEntry(1111).getKey()); } / *获取离给定key最近的key * @Param */ @Test public void testFloorKey()throws Exception{ ConcurrentSkipListMap 
                                                            
                                                              map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(1,2); System.out.println(map.floorKey(222)); } / *获取比给定key大于和等于的第一个entry * @Param */ @Test public void testCeilingEntry()throws Exception{ ConcurrentSkipListMap 
                                                             
                                                               map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(4,333); map.put(1,2); System.out.println(map.ceilingEntry(4)); } / *获取比给定key大于和等于的第一个key * @Param */ @Test public void testCeilingKey()throws Exception{ ConcurrentSkipListMap 
                                                              
                                                                map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(4,333); map.put(1,2); System.out.println(map.ceilingKey(4)); } / * 获取比指定key大于的entry * @Param */ @Test public void testHigherEntry()throws Exception{ ConcurrentSkipListMap 
                                                               
                                                                 map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(4,333); map.put(1,2); System.out.println(map.higherEntry(4)); } / *获取比指定key大于的key * @Param */ @Test public void testHigherKey()throws Exception{ ConcurrentSkipListMap 
                                                                
                                                                  map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(4,333); map.put(1,2); System.out.println(map.higherKey(4)); } / *获取排序后的第一个entry * @Param */ @Test public void testFirstEntry()throws Exception{ ConcurrentSkipListMap 
                                                                 
                                                                   map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(4,333); map.put(1,2); System.out.println(map.firstEntry()); } / *获取排序后的最后一个entry * @Param */ @Test public void testLastEntry()throws Exception{ ConcurrentSkipListMap 
                                                                  
                                                                    map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(4,333); map.put(1,2); System.out.println(map.lastEntry()); } / *获取排序后的第一个entry,并移除 * @Param */ @Test public void testPollFirstEntry()throws Exception{ ConcurrentSkipListMap 
                                                                   
                                                                     map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(4,333); map.put(1,2); System.out.println(map.pollFirstEntry()); System.out.println(map.pollFirstEntry()); } / *获取排序后的最后一个entry,并移除 * @Param */ @Test public void testPollLastEntry()throws Exception{ ConcurrentSkipListMap 
                                                                    
                                                                      map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(4,333); map.put(1,2); System.out.println(map.pollLastEntry()); System.out.println(map.pollLastEntry()); } / *遍历所有键值对 * @Param */ @Test public void testForEach()throws Exception{ ConcurrentSkipListMap 
                                                                     
                                                                       map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(4,333); map.put(1,2); map.forEach((key,val)-> System.out.println(key+val)); } / * 将BiFunction计算结果替换到key对应的value中 * @Param */ @Test public void testReplaceAll()throws Exception{ ConcurrentSkipListMap 
                                                                      
                                                                        map=new ConcurrentSkipListMap<>(); map.put(3,4); map.put(5,6); map.put(4,333); map.put(1,2); map.replaceAll((key,val)-> key+val); System.out.println(111); } }