HashMap源码解析(JDK1.8)

   1 package java.util;
   2 
   3 import sun.misc.SharedSecrets;
   4 
   5 import java.io.IOException;
   6 import java.io.InvalidObjectException;
   7 import java.io.Serializable;
   8 import java.lang.reflect.ParameterizedType;
   9 import java.lang.reflect.Type;
  10 import java.util.function.BiConsumer;
  11 import java.util.function.BiFunction;
  12 import java.util.function.Consumer;
  13 import java.util.function.Function;
  14 
  15 /**
  16  * HashMap是常用的Java集合之一,是基于哈希表的Map接口的实现。与HashTable主要区别为不支持同步和允许null作为key和value。
  17  * HashMap非线程安全,即任一时刻可以有多个线程同时写HashMap,可能会导致数据的不一致。
  18  * 如果需要满足线程安全,可以用 Collections的synchronizedMap方法使HashMap具有线程安全的能力,或者使用ConcurrentHashMap。
  19  * 在JDK1.6中,HashMap采用数组+链表实现,即使用链表处理冲突,同一hash值的链表都存储在一个链表里。
  20  * 但是当位于一个数组中的元素较多,即hash值相等的元素较多时,通过key值依次查找的效率较低。
  21  * 而JDK1.8中,HashMap采用数组+链表+红黑树实现,当链表长度超过阈值8时,将链表转换为红黑树,这样大大减少了查找时间。
  22  * 原本Map.Entry接口的实现类Entry改名为了Node。转化为红黑树时改用另一种实现TreeNode。
  23  */
  24 public class HashMap<K, V> extends AbstractMap<K, V>
  25         implements Map<K, V>, Cloneable, Serializable {
  26 
  27     private static final long serialVersionUID = 362498820763181265L;
  28 
  29 
  30     /**
  31      * 默认的初始容量(容量为HashMap中槽的数目)是16,且实际容量必须是2的整数次幂。
  32      */
  33     static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
  34 
  35     /**
  36      * 最大容量(必须是2的幂且小于2的30次方,传入容量过大将被这个值替换)
  37      */
  38     static final int MAXIMUM_CAPACITY = 1 << 30;
  39 
  40     /**
  41      * 默认装填因子0.75,如果当前键值对个数 >= HashMap最大容量*装填因子,进行rehash操作
  42      */
  43     static final float DEFAULT_LOAD_FACTOR = 0.75f;
  44 
  45     /**
  46      * JDK1.8 新加,Entry链表最大长度,当桶中节点数目大于该长度时,将链表转成红黑树存储;
  47      */
  48     static final int TREEIFY_THRESHOLD = 8;
  49 
  50     /**
  51      * JDK1.8 新加,当桶中节点数小于该长度,将红黑树转为链表存储;
  52      */
  53     static final int UNTREEIFY_THRESHOLD = 6;
  54 
  55     /**
  56      * 桶可能被转化为树形结构的最小容量。当哈希表的大小超过这个阈值,才会把链式结构转化成树型结构,否则仅采取扩容来尝试减少冲突。
  57      * 应该至少4*TREEIFY_THRESHOLD来避免扩容和树形结构化之间的冲突。
  58      */
  59     static final int MIN_TREEIFY_CAPACITY = 64;
  60 
  61     /**
  62      * JDK1.6用Entry描述键值对,JDK1.8中用Node代替Entry
  63      */
  64     static class Node<K, V> implements Map.Entry<K, V> {
  65         // hash存储key的hashCode
  66         final int hash;
  67         // final:一个键值对的key不可改变
  68         final K key;
  69         V value;
  70         //指向下个节点的引用
  71         Node<K, V> next;
  72 
  73         //构造函数
  74         Node(int hash, K key, V value, Node<K, V> next) {
  75             this.hash = hash;
  76             this.key = key;
  77             this.value = value;
  78             this.next = next;
  79         }
  80 
  81         public final K getKey() {
  82             return key;
  83         }
  84 
  85         public final V getValue() {
  86             return value;
  87         }
  88 
  89         public final String toString() {
  90             return key + "=" + value;
  91         }
  92 
  93         public final int hashCode() {
  94             return Objects.hashCode(key) ^ Objects.hashCode(value);
  95         }
  96 
  97         public final V setValue(V newValue) {
  98             V oldValue = value;
  99             value = newValue;
 100             return oldValue;
 101         }
 102 
 103         public final boolean equals(Object o) {
 104             if (o == this)
 105                 return true;
 106             if (o instanceof Map.Entry) {
 107                 Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
 108                 if (Objects.equals(key, e.getKey()) &&
 109                         Objects.equals(value, e.getValue()))
 110                     return true;
 111             }
 112             return false;
 113         }
 114     }
 115 
 116     /* ---------------- Static utilities -------------- */
 117 
 118     /**
 119      * HashMap中键值对的存储形式为链表节点,hashCode相同的节点(位于同一个桶)用链表组织
 120      * hash方法分为三步:
 121      * 1.取key的hashCode
 122      * 2.key的hashCode高16位异或低16位
 123      * 3.将第一步和第二步得到的结果进行取模运算。
 124      */
 125     static final int hash(Object key) {
 126         int h;
 127         //计算key的hashCode, h = Objects.hashCode(key)
 128         //h >>> 16表示对h无符号右移16位,高位补0,然后h与h >>> 16按位异或
 129         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 130     }
 131 
 132     /**
 133      * 如果参数x实现了Comparable接口,返回参数x的类名,否则返回null
 134      */
 135     static Class<?> comparableClassFor(Object x) {
 136         if (x instanceof Comparable) {
 137             Class<?> c;
 138             Type[] ts, as;
 139             Type t;
 140             ParameterizedType p;
 141             if ((c = x.getClass()) == String.class) // bypass checks
 142                 return c;
 143             if ((ts = c.getGenericInterfaces()) != null) {
 144                 for (int i = 0; i < ts.length; ++i) {
 145                     if (((t = ts[i]) instanceof ParameterizedType) &&
 146                             ((p = (ParameterizedType) t).getRawType() ==
 147                                     Comparable.class) &&
 148                             (as = p.getActualTypeArguments()) != null &&
 149                             as.length == 1 && as[0] == c) // type arg is c
 150                         return c;
 151                 }
 152             }
 153         }
 154         return null;
 155     }
 156 
 157     /**
 158      * 如果x的类型为kc,则返回k.compareTo(x),否则返回0
 159      */
 160     @SuppressWarnings({"rawtypes", "unchecked"}) // for cast to Comparable
 161     static int compareComparables(Class<?> kc, Object k, Object x) {
 162         return (x == null || x.getClass() != kc ? 0 :
 163                 ((Comparable) k).compareTo(x));
 164     }
 165 
 166     /**
 167      * 结果为>=cap的最小2的自然数幂
 168      */
 169     static final int tableSizeFor(int cap) {
 170         //先移位再或运算,最终保证返回值是2的整数幂
 171         int n = cap - 1;
 172         n |= n >>> 1;
 173         n |= n >>> 2;
 174         n |= n >>> 4;
 175         n |= n >>> 8;
 176         n |= n >>> 16;
 177         return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
 178     }
 179 
 180     /* ---------------- Fields -------------- */
 181 
 182     /**
 183      * 哈希桶数组,分配的时候,table的长度总是2的幂
 184      */
 185     transient Node<K, V>[] table;
 186 
 187     /**
 188      * HashMap将数据转换成set的另一种存储形式,这个变量主要用于迭代功能
 189      */
 190     transient Set<Map.Entry<K, V>> entrySet;
 191 
 192     /**
 193      * 实际存储的数量,则HashMap的size()方法,实际返回的就是这个值,isEmpty()也是判断该值是否为0
 194      */
 195     transient int size;
 196 
 197     /**
 198      * hashmap结构被改变的次数,fail-fast机制
 199      */
 200     transient int modCount;
 201 
 202     /**
 203      * HashMap的扩容阈值,在HashMap中存储的Node键值对超过这个数量时,自动扩容容量为原来的二倍
 204      *
 205      * @serial
 206      */
 207     int threshold;
 208 
 209     /**
 210      * HashMap的负加载因子,可计算出当前table长度下的扩容阈值:threshold = loadFactor * table.length
 211      *
 212      * @serial
 213      */
 214     final float loadFactor;
 215 
 216     /* ---------------- Public operations -------------- */
 217 
 218     /**
 219      * 使用指定的初始化容量initial capacity 和加载因子load factor构造一个空HashMap
 220      *
 221      * @param initialCapacity 初始化容量
 222      * @param loadFactor      加载因子
 223      * @throws IllegalArgumentException 如果指定的初始化容量为负数或者加载因子为非正数
 224      */
 225     public HashMap(int initialCapacity, float loadFactor) {
 226         if (initialCapacity < 0)
 227             throw new IllegalArgumentException("Illegal initial capacity: " +
 228                     initialCapacity);
 229         if (initialCapacity > MAXIMUM_CAPACITY)
 230             initialCapacity = MAXIMUM_CAPACITY;
 231         if (loadFactor <= 0 || Float.isNaN(loadFactor))
 232             throw new IllegalArgumentException("Illegal load factor: " +
 233                     loadFactor);
 234         this.loadFactor = loadFactor;
 235         this.threshold = tableSizeFor(initialCapacity);
 236     }
 237 
 238     /**
 239      * 使用指定的初始化容量initial capacity和默认加载因子DEFAULT_LOAD_FACTOR(0.75)构造一个空HashMap
 240      *
 241      * @param initialCapacity 初始化容量
 242      * @throws IllegalArgumentException 如果指定的初始化容量为负数
 243      */
 244     public HashMap(int initialCapacity) {
 245         this(initialCapacity, DEFAULT_LOAD_FACTOR);
 246     }
 247 
 248     /**
 249      * 使用指定的初始化容量(16)和默认加载因子DEFAULT_LOAD_FACTOR(0.75)构造一个空HashMap
 250      */
 251     public HashMap() {
 252         this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
 253     }
 254 
 255     /**
 256      * 使用指定Map m构造新的HashMap。使用指定的初始化容量(16)和默认加载因子DEFAULT_LOAD_FACTOR(0.75)
 257      *
 258      * @param m 指定的map
 259      * @throws NullPointerException 如果指定的map是null
 260      */
 261     public HashMap(Map<? extends K, ? extends V> m) {
 262         this.loadFactor = DEFAULT_LOAD_FACTOR;
 263         putMapEntries(m, false);
 264     }
 265 
 266     /**
 267      * Map.putAll and Map constructor的实现需要的方法
 268      * 将m的键值对插入本map中
 269      *
 270      * @param m     指定的map
 271      * @param evict 初始化map时使用false,否则使用true
 272      */
 273     final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
 274         int s = m.size();
 275         //如果参数map不为空
 276         if (s > 0) {
 277             // 判断table是否已经初始化
 278             if (table == null) { // pre-size
 279                 // 未初始化,s为m的实际元素个数
 280                 float ft = ((float) s / loadFactor) + 1.0F;
 281                 int t = ((ft < (float) MAXIMUM_CAPACITY) ?
 282                         (int) ft : MAXIMUM_CAPACITY);
 283                 // 计算得到的t大于阈值,则初始化阈值
 284                 if (t > threshold)
 285                     //根据容量初始化临界值
 286                     threshold = tableSizeFor(t);
 287                 // 已初始化,并且m元素个数大于阈值,进行扩容处理
 288             } else if (s > threshold)
 289                 //扩容处理
 290                 resize();
 291             // 将m中的所有元素添加至HashMap中
 292             for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
 293                 K key = e.getKey();
 294                 V value = e.getValue();
 295                 putVal(hash(key), key, value, false, evict);
 296             }
 297         }
 298     }
 299 
 300     /**
 301      * 返回map中键值对映射的个数
 302      *
 303      * @return map中键值对映射的个数
 304      */
 305     public int size() {
 306         return size;
 307     }
 308 
 309     /**
 310      * 如果map中没有键值对映射,返回true
 311      *
 312      * @return 如果map中没有键值对映射,返回true
 313      */
 314     public boolean isEmpty() {
 315         return size == 0;
 316     }
 317 
 318     /**
 319      * 返回指定的key映射的value,如果value为null,则返回null
 320      * get可以分为三个步骤:
 321      * 1.通过hash(Object key)方法计算key的哈希值hash。
 322      * 2.通过getNode( int hash, Object key)方法获取node。
 323      * 3.如果node为null,返回null,否则返回node.value。
 324      *
 325      * @see #put(Object, Object)
 326      */
 327     public V get(Object key) {
 328         Node<K, V> e;
 329         //根据key及其hash值查询node节点,如果存在,则返回该节点的value值
 330         return (e = getNode(hash(key), key)) == null ? null : e.value;
 331     }
 332 
 333     /**
 334      * 根据key的哈希值和key获取对应的节点
 335      * getNode可分为以下几个步骤:
 336      * 1.如果哈希表为空,或key对应的桶为空,返回null
 337      * 2.如果桶中的第一个节点就和指定参数hash和key匹配上了,返回这个节点。
 338      * 3.如果桶中的第一个节点没有匹配上,而且有后续节点
 339      * 3.1如果当前的桶采用红黑树,则调用红黑树的get方法去获取节点
 340      * 3.2如果当前的桶不采用红黑树,即桶中节点结构为链式结构,遍历链表,直到key匹配
 341      * 4.找到节点返回null,否则返回null。
 342      *
 343      * @param hash 指定参数key的哈希值
 344      * @param key  指定参数key
 345      * @return 返回node,如果没有则返回null
 346      */
 347     final Node<K, V> getNode(int hash, Object key) {
 348         Node<K, V>[] tab;
 349         Node<K, V> first, e;
 350         int n;
 351         K k;
 352         //如果哈希表不为空,而且key对应的桶上不为空
 353         if ((tab = table) != null && (n = tab.length) > 0 &&
 354                 (first = tab[(n - 1) & hash]) != null) {
 355             //如果桶中的第一个节点就和指定参数hash和key匹配上了
 356             if (first.hash == hash && // always check first node
 357                     ((k = first.key) == key || (key != null && key.equals(k))))
 358                 //返回桶中的第一个节点
 359                 return first;
 360             //如果桶中的第一个节点没有匹配上,而且有后续节点
 361             if ((e = first.next) != null) {
 362                 //如果当前的桶采用红黑树,则调用红黑树的get方法去获取节点
 363                 if (first instanceof TreeNode)
 364                     return ((TreeNode<K, V>) first).getTreeNode(hash, key);
 365                 //如果当前的桶不采用红黑树,即桶中节点结构为链式结构
 366                 do {
 367                     //遍历链表,直到key匹配
 368                     if (e.hash == hash &&
 369                             ((k = e.key) == key || (key != null && key.equals(k))))
 370                         return e;
 371                 } while ((e = e.next) != null);
 372             }
 373         }
 374         //如果哈希表为空,或者没有找到节点,返回null
 375         return null;
 376     }
 377 
 378     /**
 379      * 如果map中含有key为指定参数key的键值对,返回true
 380      *
 381      * @param key 指定参数key
 382      * @return 如果map中含有key为指定参数key的键值对,返回true
 383      * key.
 384      */
 385     public boolean containsKey(Object key) {
 386         return getNode(hash(key), key) != null;
 387     }
 388 
 389     /**
 390      * 将指定参数key和指定参数value插入map中,如果key已经存在,那就替换key对应的value
 391      * put(K key, V value)可以分为三个步骤:
 392      * 1.通过hash(Object key)方法计算key的哈希值。
 393      * 2.通过putVal(hash(key), key, value, false, true)方法实现功能。
 394      * 3.返回putVal方法返回的结果。
 395      *
 396      * @param key   指定key
 397      * @param value 指定value
 398      * @return 如果value被替换,则返回旧的value,否则返回null。当然,可能key对应的value就是null
 399      */
 400     public V put(K key, V value) {
 401         // 倒数第二个参数false:表示允许旧值替换
 402         // 最后一个参数true:表示HashMap不处于创建模式
 403         return putVal(hash(key), key, value, false, true);
 404     }
 405 
 406     /**
 407      * Map.put和其他相关方法的实现需要的方法
 408      * putVal方法可以分为下面的几个步骤:
 409      * 1.如果哈希表为空,调用resize()创建一个哈希表。
 410      * 2.如果指定参数hash在表中没有对应的桶,即为没有碰撞,直接将键值对插入到哈希表中即可。
 411      * 3.如果有碰撞,遍历桶,找到key映射的节点
 412      * 3.1桶中的第一个节点就匹配了,将桶中的第一个节点记录起来。
 413      * 3.2如果桶中的第一个节点没有匹配,且桶中结构为红黑树,则调用红黑树对应的方法插入键值对。
 414      * 3.3如果不是红黑树,那么就肯定是链表。遍历链表,如果找到了key映射的节点,就记录这个节点,退出循环。如果没有找到,在链表尾部插入节点。插入后,如果链的长度大于TREEIFY_THRESHOLD这个临界值,则使用treeifyBin方法把链表转为红黑树。
 415      * 4.如果找到了key映射的节点,且节点不为null
 416      * 4.1记录节点的vlaue。
 417      * 4.2如果参数onlyIfAbsent为false,或者oldValue为null,替换value,否则不替换。
 418      * 4.3返回记录下来的节点的value。
 419      * 5.如果没有找到key映射的节点(2、3步中讲了,这种情况会插入到hashMap中),插入节点后size会加1,这时要检查size是否大于临界值threshold,如果大于会使用resize方法进行扩容。
 420      *
 421      * @param hash         指定参数key的哈希值
 422      * @param key          指定参数key
 423      * @param value        指定参数value
 424      * @param onlyIfAbsent 如果为true,即使指定参数key在map中已经存在,也不会替换value
 425      * @param evict        如果为false,数组table在创建模式中
 426      * @return 如果value被替换,则返回旧的value,否则返回null。当然,可能key对应的value就是null。
 427      */
 428     final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 429                    boolean evict) {
 430         Node<K, V>[] tab;
 431         Node<K, V> p;
 432         int n, i;
 433         //如果哈希表为空,调用resize()创建一个哈希表,并用变量n记录哈希表长度
 434         if ((tab = table) == null || (n = tab.length) == 0)
 435             n = (tab = resize()).length;
 436         /**
 437          * 如果指定参数hash在表中没有对应的桶,即为没有碰撞
 438          * Hash函数,(n - 1) & hash 计算key将被放置的槽位
 439          * (n - 1) & hash 本质上是hash % n,位运算更快
 440          */
 441         if ((p = tab[i = (n - 1) & hash]) == null)
 442             //直接将键值对插入到map中即可
 443             tab[i] = newNode(hash, key, value, null);
 444         else {// 桶中已经存在元素
 445             Node<K, V> e;
 446             K k;
 447             // 比较桶中第一个元素(数组中的结点)的hash值相等,key相等
 448             if (p.hash == hash &&
 449                     ((k = p.key) == key || (key != null && key.equals(k))))
 450                 // 将第一个元素赋值给e,用e来记录
 451                 e = p;
 452                 // 当前桶中无该键值对,且桶是红黑树结构,按照红黑树结构插入
 453             else if (p instanceof TreeNode)
 454                 e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
 455                 // 当前桶中无该键值对,且桶是链表结构,按照链表结构插入到尾部
 456             else {
 457                 for (int binCount = 0; ; ++binCount) {
 458                     // 遍历到链表尾部
 459                     if ((e = p.next) == null) {
 460                         p.next = newNode(hash, key, value, null);
 461                         // 检查链表长度是否达到阈值,达到将该槽位节点组织形式转为红黑树
 462                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
 463                             treeifyBin(tab, hash);
 464                         break;
 465                     }
 466                     // 链表节点的<key, value>与put操作<key, value>相同时,不做重复操作,跳出循环
 467                     if (e.hash == hash &&
 468                             ((k = e.key) == key || (key != null && key.equals(k))))
 469                         break;
 470                     p = e;
 471                 }
 472             }
 473             // 找到或新建一个key和hashCode与插入元素相等的键值对,进行put操作
 474             if (e != null) { // existing mapping for key
 475                 // 记录e的value
 476                 V oldValue = e.value;
 477                 /**
 478                  * onlyIfAbsent为false或旧值为null时,允许替换旧值
 479                  * 否则无需替换
 480                  */
 481                 if (!onlyIfAbsent || oldValue == null)
 482                     e.value = value;
 483                 // 访问后回调
 484                 afterNodeAccess(e);
 485                 // 返回旧值
 486                 return oldValue;
 487             }
 488         }
 489         // 更新结构化修改信息
 490         ++modCount;
 491         // 键值对数目超过阈值时,进行rehash
 492         if (++size > threshold)
 493             resize();
 494         // 插入后回调
 495         afterNodeInsertion(evict);
 496         return null;
 497     }
 498 
 499     /**
 500      * 对table进行初始化或者扩容。
 501      * 如果table为null,则对table进行初始化
 502      * 如果对table扩容,因为每次扩容都是翻倍,与原来计算(n-1)&hash的结果相比,节点要么就在原来的位置,要么就被分配到“原位置+旧容量”这个位置
 503      * resize的步骤总结为:
 504      * 1.计算扩容后的容量,临界值。
 505      * 2.将hashMap的临界值修改为扩容后的临界值
 506      * 3.根据扩容后的容量新建数组,然后将hashMap的table的引用指向新数组。
 507      * 4.将旧数组的元素复制到table中。
 508      *
 509      * @return the table
 510      */
 511     final Node<K, V>[] resize() {
 512         //新建oldTab数组保存扩容前的数组table
 513         Node<K, V>[] oldTab = table;
 514         //获取原来数组的长度
 515         int oldCap = (oldTab == null) ? 0 : oldTab.length;
 516         //原来数组扩容的临界值
 517         int oldThr = threshold;
 518         int newCap, newThr = 0;
 519         //如果扩容前的容量 > 0
 520         if (oldCap > 0) {
 521             //如果原来的数组长度大于最大值(2^30)
 522             if (oldCap >= MAXIMUM_CAPACITY) {
 523                 //扩容临界值提高到正无穷
 524                 threshold = Integer.MAX_VALUE;
 525                 //无法进行扩容,返回原来的数组
 526                 return oldTab;
 527                 //如果现在容量的两倍小于MAXIMUM_CAPACITY且现在的容量大于DEFAULT_INITIAL_CAPACITY
 528             } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
 529                     oldCap >= DEFAULT_INITIAL_CAPACITY)
 530                 //临界值变为原来的2倍
 531                 newThr = oldThr << 1;
 532         } else if (oldThr > 0) //如果旧容量 <= 0,而且旧临界值 > 0
 533             //数组的新容量设置为老数组扩容的临界值
 534             newCap = oldThr;
 535         else { //如果旧容量 <= 0,且旧临界值 <= 0,新容量扩充为默认初始化容量,新临界值为DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY
 536             newCap = DEFAULT_INITIAL_CAPACITY;//新数组初始容量设置为默认值
 537             newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//计算默认容量下的阈值
 538         }
 539         // 计算新的resize上限
 540         if (newThr == 0) {//在当上面的条件判断中,只有oldThr > 0成立时,newThr == 0
 541             //ft为临时临界值,下面会确定这个临界值是否合法,如果合法,那就是真正的临界值
 542             float ft = (float) newCap * loadFactor;
 543             //当新容量< MAXIMUM_CAPACITY且ft < (float)MAXIMUM_CAPACITY,新的临界值为ft,否则为Integer.MAX_VALUE
 544             newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
 545                     (int) ft : Integer.MAX_VALUE);
 546         }
 547         //将扩容后hashMap的临界值设置为newThr
 548         threshold = newThr;
 549         //创建新的table,初始化容量为newCap
 550         @SuppressWarnings({"rawtypes", "unchecked"})
 551         Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
 552         //修改hashMap的table为新建的newTab
 553         table = newTab;
 554         //如果旧table不为空,将旧table中的元素复制到新的table中
 555         if (oldTab != null) {
 556             //遍历旧哈希表的每个桶,将旧哈希表中的桶复制到新的哈希表中
 557             for (int j = 0; j < oldCap; ++j) {
 558                 Node<K, V> e;
 559                 //如果旧桶不为null,使用e记录旧桶
 560                 if ((e = oldTab[j]) != null) {
 561                     //将旧桶置为null
 562                     oldTab[j] = null;
 563                     //如果旧桶中只有一个node
 564                     if (e.next == null)
 565                         //将e也就是oldTab[j]放入newTab中e.hash & (newCap - 1)的位置
 566                         newTab[e.hash & (newCap - 1)] = e;
 567                         //如果旧桶中的结构为红黑树
 568                     else if (e instanceof TreeNode)
 569                         //将树中的node分离
 570                         ((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
 571                     else {  //如果旧桶中的结构为链表,链表重排,jdk1.8做的一系列优化
 572                         Node<K, V> loHead = null, loTail = null;
 573                         Node<K, V> hiHead = null, hiTail = null;
 574                         Node<K, V> next;
 575                         //遍历整个链表中的节点
 576                         do {
 577                             next = e.next;
 578                             // 原索引
 579                             if ((e.hash & oldCap) == 0) {
 580                                 if (loTail == null)
 581                                     loHead = e;
 582                                 else
 583                                     loTail.next = e;
 584                                 loTail = e;
 585                             } else {// 原索引+oldCap
 586                                 if (hiTail == null)
 587                                     hiHead = e;
 588                                 else
 589                                     hiTail.next = e;
 590                                 hiTail = e;
 591                             }
 592                         } while ((e = next) != null);
 593                         // 原索引放到bucket里
 594                         if (loTail != null) {
 595                             loTail.next = null;
 596                             newTab[j] = loHead;
 597                         }
 598                         // 原索引+oldCap放到bucket里
 599                         if (hiTail != null) {
 600                             hiTail.next = null;
 601                             newTab[j + oldCap] = hiHead;
 602                         }
 603                     }
 604                 }
 605             }
 606         }
 607         return newTab;
 608     }
 609 
 610     /**
 611      * 将链表转化为红黑树
 612      */
 613     final void treeifyBin(Node<K, V>[] tab, int hash) {
 614         int n, index;
 615         Node<K, V> e;
 616         //如果桶数组table为空,或者桶数组table的长度小于MIN_TREEIFY_CAPACITY,不符合转化为红黑树的条件
 617         if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
 618             //扩容
 619             resize();
 620             //如果符合转化为红黑树的条件,而且hash对应的桶不为null
 621         else if ((e = tab[index = (n - 1) & hash]) != null) {
 622             // 红黑树的头、尾节点
 623             TreeNode<K, V> hd = null, tl = null;
 624             //遍历链表
 625             do {
 626                 //替换链表node为树node,建立双向链表
 627                 TreeNode<K, V> p = replacementTreeNode(e, null);
 628                 // 确定树头节点
 629                 if (tl == null)
 630                     hd = p;
 631                 else {
 632                     p.prev = tl;
 633                     tl.next = p;
 634                 }
 635                 tl = p;
 636             } while ((e = e.next) != null);
 637             //遍历链表插入每个节点到红黑树
 638             if ((tab[index] = hd) != null)
 639                 hd.treeify(tab);
 640         }
 641     }
 642 
 643     /**
 644      * 将参数map中的所有键值对映射插入到hashMap中,如果有碰撞,则覆盖value。
 645      *
 646      * @param m 参数map
 647      * @throws NullPointerException 如果map为null
 648      */
 649     public void putAll(Map<? extends K, ? extends V> m) {
 650         putMapEntries(m, true);
 651     }
 652 
 653     /**
 654      * 删除hashMap中key映射的node
 655      * remove方法的实现可以分为三个步骤:
 656      * 1.通过 hash(Object key)方法计算key的哈希值。
 657      * 2.通过 removeNode 方法实现功能。
 658      * 3.返回被删除的node的value。
 659      *
 660      * @param key 参数key
 661      * @return 如果没有映射到node,返回null,否则返回对应的value
 662      */
 663     public V remove(Object key) {
 664         Node<K, V> e;
 665         //根据key来删除node。removeNode方法的具体实现在下面
 666         return (e = removeNode(hash(key), key, null, false, true)) == null ?
 667                 null : e.value;
 668     }
 669 
 670     /**
 671      * Map.remove和相关方法的实现需要的方法
 672      * removeNode方法的步骤总结为:
 673      * 1.如果数组table为空或key映射到的桶为空,返回null。
 674      * 2.如果key映射到的桶上第一个node的就是要删除的node,记录下来。
 675      * 3.如果桶内不止一个node,且桶内的结构为红黑树,记录key映射到的node。
 676      * 4.桶内的结构不为红黑树,那么桶内的结构就肯定为链表,遍历链表,找到key映射到的node,记录下来。
 677      * 5.如果被记录下来的node不为null,删除node,size-1被删除。
 678      * 6.返回被删除的node。
 679      *
 680      * @param hash       key的哈希值
 681      * @param key        key的哈希值
 682      * @param value      如果 matchValue 为true,则value也作为确定被删除的node的条件之一,否则忽略
 683      * @param matchValue 如果为true,则value也作为确定被删除的node的条件之一
 684      * @param movable    如果为false,删除node时不会删除其他node
 685      * @return 返回被删除的node,如果没有node被删除,则返回null(针对红黑树的删除方法)
 686      */
 687     final Node<K, V> removeNode(int hash, Object key, Object value,
 688                                 boolean matchValue, boolean movable) {
 689         Node<K, V>[] tab;
 690         Node<K, V> p;
 691         int n, index;
 692         //如果数组table不为空且key映射到的桶不为空
 693         if ((tab = table) != null && (n = tab.length) > 0 &&
 694                 (p = tab[index = (n - 1) & hash]) != null) {
 695             Node<K, V> node = null, e;
 696             K k;
 697             V v;
 698             //如果桶上第一个node的就是要删除的node
 699             if (p.hash == hash &&
 700                     ((k = p.key) == key || (key != null && key.equals(k))))
 701                 //记录桶上第一个node
 702                 node = p;
 703             else if ((e = p.next) != null) {//如果桶内不止一个node
 704                 //如果桶内的结构为红黑树
 705                 if (p instanceof TreeNode)
 706                     //记录key映射到的node
 707                     node = ((TreeNode<K, V>) p).getTreeNode(hash, key);
 708                 else {//如果桶内的结构为链表
 709                     do {//遍历链表,找到key映射到的node
 710                         if (e.hash == hash &&
 711                                 ((k = e.key) == key ||
 712                                         (key != null && key.equals(k)))) {
 713                             //记录key映射到的node
 714                             node = e;
 715                             break;
 716                         }
 717                         p = e;
 718                     } while ((e = e.next) != null);
 719                 }
 720             }
 721             //如果得到的node不为null且(matchValue为false||node.value和参数value匹配)
 722             if (node != null && (!matchValue || (v = node.value) == value ||
 723                     (value != null && value.equals(v)))) {
 724                 //如果桶内的结构为红黑树
 725                 if (node instanceof TreeNode)
 726                     //使用红黑树的删除方法删除node
 727                     ((TreeNode<K, V>) node).removeTreeNode(this, tab, movable);
 728                 else if (node == p)//如果桶的第一个node的就是要删除的node
 729                     //删除node
 730                     tab[index] = node.next;
 731                 else//如果桶内的结构为链表,使用链表删除元素的方式删除node
 732                     p.next = node.next;
 733                 ++modCount;//结构性修改次数+1
 734                 --size;//哈希表大小-1
 735                 afterNodeRemoval(node);
 736                 return node;//返回被删除的node
 737             }
 738         }
 739         return null;//如果数组table为空或key映射到的桶为空,返回null。
 740     }
 741 
 742     /**
 743      * 删除map中所有的键值对
 744      */
 745     public void clear() {
 746         Node<K, V>[] tab;
 747         modCount++;
 748         if ((tab = table) != null && size > 0) {
 749             size = 0;
 750             for (int i = 0; i < tab.length; ++i)
 751                 tab[i] = null;
 752         }
 753     }
 754 
 755     /**
 756      * 如果hashMap中的键值对有一对或多对的value为参数value,返回true
 757      *
 758      * @param value 参数value
 759      * @return 如果hashMap中的键值对有一对或多对的value为参数value,返回true
 760      */
 761     public boolean containsValue(Object value) {
 762         Node<K, V>[] tab;
 763         V v;
 764         if ((tab = table) != null && size > 0) {
 765             //遍历数组table
 766             for (int i = 0; i < tab.length; ++i) {
 767                 //遍历桶中的node
 768                 for (Node<K, V> e = tab[i]; e != null; e = e.next) {
 769                     if ((v = e.value) == value ||
 770                             (value != null && value.equals(v)))
 771                         return true;
 772                 }
 773             }
 774         }
 775         return false;
 776     }
 777 
 778     /**
 779      * 返回hashMap中所有key的视图。
 780      * 改变hashMap会影响到set,反之亦然。
 781      * 如果当迭代器迭代set时,hashMap被修改(除非是迭代器自己的remove()方法),迭代器的结果是不确定的。
 782      * set支持元素的删除,通过Iterator.remove、Set.remove、removeAll、retainAll、clear操作删除hashMap中对应的键值对。
 783      * 不支持add和addAll方法。
 784      *
 785      * @return 返回hashMap中所有key的set视图
 786      */
 787     public Set<K> keySet() {
 788         Set<K> ks = keySet;
 789         if (ks == null) {
 790             ks = new KeySet();
 791             keySet = ks;
 792         }
 793         return ks;
 794     }
 795 
 796     /**
 797      * 内部类KeySet
 798      */
 799     final class KeySet extends AbstractSet<K> {
 800         public final int size() {
 801             return size;
 802         }
 803 
 804         public final void clear() {
 805             HashMap.this.clear();
 806         }
 807 
 808         public final Iterator<K> iterator() {
 809             return new KeyIterator();
 810         }
 811 
 812         public final boolean contains(Object o) {
 813             return containsKey(o);
 814         }
 815 
 816         public final boolean remove(Object key) {
 817             return removeNode(hash(key), key, null, false, true) != null;
 818         }
 819 
 820         public final Spliterator<K> spliterator() {
 821             return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
 822         }
 823 
 824         public final void forEach(Consumer<? super K> action) {
 825             Node<K, V>[] tab;
 826             if (action == null)
 827                 throw new NullPointerException();
 828             if (size > 0 && (tab = table) != null) {
 829                 int mc = modCount;
 830                 for (int i = 0; i < tab.length; ++i) {
 831                     for (Node<K, V> e = tab[i]; e != null; e = e.next)
 832                         action.accept(e.key);
 833                 }
 834                 if (modCount != mc)
 835                     throw new ConcurrentModificationException();
 836             }
 837         }
 838     }
 839 
 840     /**
 841      * 返回hashMap中所有value的collection视图
 842      * 改变hashMap会改变collection,反之亦然。
 843      * 如果当迭代器迭代collection时,hashMap被修改(除非是迭代器自己的remove()方法),迭代器的结果是不确定的。
 844      * collection支持元素的删除,通过Iterator.remove、Collection.remove、removeAll、retainAll、clear操作删除hashMap中对应的键值对。
 845      * 不支持add和addAll方法。
 846      *
 847      * @return 返回hashMap中所有key的collection视图
 848      */
 849     public Collection<V> values() {
 850         Collection<V> vs = values;
 851         if (vs == null) {
 852             vs = new Values();
 853             values = vs;
 854         }
 855         return vs;
 856     }
 857 
 858     /**
 859      * 内部类Values
 860      */
 861     final class Values extends AbstractCollection<V> {
 862         public final int size() {
 863             return size;
 864         }
 865 
 866         public final void clear() {
 867             HashMap.this.clear();
 868         }
 869 
 870         public final Iterator<V> iterator() {
 871             return new ValueIterator();
 872         }
 873 
 874         public final boolean contains(Object o) {
 875             return containsValue(o);
 876         }
 877 
 878         public final Spliterator<V> spliterator() {
 879             return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
 880         }
 881 
 882         public final void forEach(Consumer<? super V> action) {
 883             Node<K, V>[] tab;
 884             if (action == null)
 885                 throw new NullPointerException();
 886             if (size > 0 && (tab = table) != null) {
 887                 int mc = modCount;
 888                 for (int i = 0; i < tab.length; ++i) {
 889                     for (Node<K, V> e = tab[i]; e != null; e = e.next)
 890                         action.accept(e.value);
 891                 }
 892                 if (modCount != mc)
 893                     throw new ConcurrentModificationException();
 894             }
 895         }
 896     }
 897 
 898     /**
 899      * 返回hashMap中所有键值对的set视图
 900      * 改变hashMap会影响到set,反之亦然。
 901      * 如果当迭代器迭代set时,hashMap被修改(除非是迭代器自己的remove()方法),迭代器的结果是不确定的。
 902      * set支持元素的删除,通过Iterator.remove、Set.remove、removeAll、retainAll、clear操作删除hashMap中对应的键值对。
 903      * 不支持add和addAll方法。
 904      *
 905      * @return 返回hashMap中所有键值对的set视图
 906      */
 907     public Set<Map.Entry<K, V>> entrySet() {
 908         Set<Map.Entry<K, V>> es;
 909         return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
 910     }
 911 
 912     /**
 913      * 内部类EntrySet
 914      */
 915     final class EntrySet extends AbstractSet<Map.Entry<K, V>> {
 916         public final int size() {
 917             return size;
 918         }
 919 
 920         public final void clear() {
 921             HashMap.this.clear();
 922         }
 923 
 924         public final Iterator<Map.Entry<K, V>> iterator() {
 925             return new EntryIterator();
 926         }
 927 
 928         public final boolean contains(Object o) {
 929             if (!(o instanceof Map.Entry))
 930                 return false;
 931             Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
 932             Object key = e.getKey();
 933             Node<K, V> candidate = getNode(hash(key), key);
 934             return candidate != null && candidate.equals(e);
 935         }
 936 
 937         public final boolean remove(Object o) {
 938             if (o instanceof Map.Entry) {
 939                 Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
 940                 Object key = e.getKey();
 941                 Object value = e.getValue();
 942                 return removeNode(hash(key), key, value, true, true) != null;
 943             }
 944             return false;
 945         }
 946 
 947         public final Spliterator<Map.Entry<K, V>> spliterator() {
 948             return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
 949         }
 950 
 951         public final void forEach(Consumer<? super Map.Entry<K, V>> action) {
 952             Node<K, V>[] tab;
 953             if (action == null)
 954                 throw new NullPointerException();
 955             if (size > 0 && (tab = table) != null) {
 956                 int mc = modCount;
 957                 for (int i = 0; i < tab.length; ++i) {
 958                     for (Node<K, V> e = tab[i]; e != null; e = e.next)
 959                         action.accept(e);
 960                 }
 961                 if (modCount != mc)
 962                     throw new ConcurrentModificationException();
 963             }
 964         }
 965     }
 966 
 967     // JDK8重写的方法
 968 
 969     /**
 970      * 通过key映射到对应node,如果没映射到则返回默认值defaultValue
 971      *
 972      * @param key
 973      * @param defaultValue
 974      * @return key映射到对应的node,如果没映射到则返回默认值defaultValue
 975      */
 976     @Override
 977     public V getOrDefault(Object key, V defaultValue) {
 978         Node<K, V> e;
 979         return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
 980     }
 981 
 982     /**
 983      * 在hashMap中插入参数key和value组成的键值对,如果key在hashMap中已经存在,不替换value
 984      *
 985      * @param key
 986      * @param value
 987      * @return 如果key在hashMap中不存在,返回旧value
 988      */
 989     @Override
 990     public V putIfAbsent(K key, V value) {
 991         return putVal(hash(key), key, value, true, true);
 992     }
 993 
 994     /**
 995      * 删除hashMap中key为参数key,value为参数value的键值对。如果桶中结构为树,则级联删除
 996      *
 997      * @param key
 998      * @param value
 999      * @return 删除成功,返回true
1000      */
1001     @Override
1002     public boolean remove(Object key, Object value) {
1003         return removeNode(hash(key), key, value, true, true) != null;
1004     }
1005 
1006     /**
1007      * 使用newValue替换key和oldValue映射到的键值对中的value
1008      *
1009      * @param key
1010      * @param oldValue
1011      * @param newValue
1012      * @return 替换成功,返回true
1013      */
1014     @Override
1015     public boolean replace(K key, V oldValue, V newValue) {
1016         Node<K, V> e;
1017         V v;
1018         if ((e = getNode(hash(key), key)) != null &&
1019                 ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
1020             e.value = newValue;
1021             afterNodeAccess(e);
1022             return true;
1023         }
1024         return false;
1025     }
1026 
1027     /**
1028      * 使用参数value替换key映射到的键值对中的value
1029      *
1030      * @param key
1031      * @param value
1032      * @return 替换成功,返回true
1033      */
1034     @Override
1035     public V replace(K key, V value) {
1036         Node<K, V> e;
1037         if ((e = getNode(hash(key), key)) != null) {
1038             V oldValue = e.value;
1039             e.value = value;
1040             afterNodeAccess(e);
1041             return oldValue;
1042         }
1043         return null;
1044     }
1045 
1046     @Override
1047     public V computeIfAbsent(K key,
1048                              Function<? super K, ? extends V> mappingFunction) {
1049         if (mappingFunction == null)
1050             throw new NullPointerException();
1051         int hash = hash(key);
1052         Node<K, V>[] tab;
1053         Node<K, V> first;
1054         int n, i;
1055         int binCount = 0;
1056         TreeNode<K, V> t = null;
1057         Node<K, V> old = null;
1058         if (size > threshold || (tab = table) == null ||
1059                 (n = tab.length) == 0)
1060             n = (tab = resize()).length;
1061         if ((first = tab[i = (n - 1) & hash]) != null) {
1062             if (first instanceof TreeNode)
1063                 old = (t = (TreeNode<K, V>) first).getTreeNode(hash, key);
1064             else {
1065                 Node<K, V> e = first;
1066                 K k;
1067                 do {
1068                     if (e.hash == hash &&
1069                             ((k = e.key) == key || (key != null && key.equals(k)))) {
1070                         old = e;
1071                         break;
1072                     }
1073                     ++binCount;
1074                 } while ((e = e.next) != null);
1075             }
1076             V oldValue;
1077             if (old != null && (oldValue = old.value) != null) {
1078                 afterNodeAccess(old);
1079                 return oldValue;
1080             }
1081         }
1082         V v = mappingFunction.apply(key);
1083         if (v == null) {
1084             return null;
1085         } else if (old != null) {
1086             old.value = v;
1087             afterNodeAccess(old);
1088             return v;
1089         } else if (t != null)
1090             t.putTreeVal(this, tab, hash, key, v);
1091         else {
1092             tab[i] = newNode(hash, key, v, first);
1093             if (binCount >= TREEIFY_THRESHOLD - 1)
1094                 treeifyBin(tab, hash);
1095         }
1096         ++modCount;
1097         ++size;
1098         afterNodeInsertion(true);
1099         return v;
1100     }
1101 
1102     public V computeIfPresent(K key,
1103                               BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
1104         if (remappingFunction == null)
1105             throw new NullPointerException();
1106         Node<K, V> e;
1107         V oldValue;
1108         int hash = hash(key);
1109         if ((e = getNode(hash, key)) != null &&
1110                 (oldValue = e.value) != null) {
1111             V v = remappingFunction.apply(key, oldValue);
1112             if (v != null) {
1113                 e.value = v;
1114                 afterNodeAccess(e);
1115                 return v;
1116             } else
1117                 removeNode(hash, key, null, false, true);
1118         }
1119         return null;
1120     }
1121 
1122     @Override
1123     public V compute(K key,
1124                      BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
1125         if (remappingFunction == null)
1126             throw new NullPointerException();
1127         int hash = hash(key);
1128         Node<K, V>[] tab;
1129         Node<K, V> first;
1130         int n, i;
1131         int binCount = 0;
1132         TreeNode<K, V> t = null;
1133         Node<K, V> old = null;
1134         if (size > threshold || (tab = table) == null ||
1135                 (n = tab.length) == 0)
1136             n = (tab = resize()).length;
1137         if ((first = tab[i = (n - 1) & hash]) != null) {
1138             if (first instanceof TreeNode)
1139                 old = (t = (TreeNode<K, V>) first).getTreeNode(hash, key);
1140             else {
1141                 Node<K, V> e = first;
1142                 K k;
1143                 do {
1144                     if (e.hash == hash &&
1145                             ((k = e.key) == key || (key != null && key.equals(k)))) {
1146                         old = e;
1147                         break;
1148                     }
1149                     ++binCount;
1150                 } while ((e = e.next) != null);
1151             }
1152         }
1153         V oldValue = (old == null) ? null : old.value;
1154         V v = remappingFunction.apply(key, oldValue);
1155         if (old != null) {
1156             if (v != null) {
1157                 old.value = v;
1158                 afterNodeAccess(old);
1159             } else
1160                 removeNode(hash, key, null, false, true);
1161         } else if (v != null) {
1162             if (t != null)
1163                 t.putTreeVal(this, tab, hash, key, v);
1164             else {
1165                 tab[i] = newNode(hash, key, v, first);
1166                 if (binCount >= TREEIFY_THRESHOLD - 1)
1167                     treeifyBin(tab, hash);
1168             }
1169             ++modCount;
1170             ++size;
1171             afterNodeInsertion(true);
1172         }
1173         return v;
1174     }
1175 
1176     @Override
1177     public V merge(K key, V value,
1178                    BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
1179         if (value == null)
1180             throw new NullPointerException();
1181         if (remappingFunction == null)
1182             throw new NullPointerException();
1183         int hash = hash(key);
1184         Node<K, V>[] tab;
1185         Node<K, V> first;
1186         int n, i;
1187         int binCount = 0;
1188         TreeNode<K, V> t = null;
1189         Node<K, V> old = null;
1190         if (size > threshold || (tab = table) == null ||
1191                 (n = tab.length) == 0)
1192             n = (tab = resize()).length;
1193         if ((first = tab[i = (n - 1) & hash]) != null) {
1194             if (first instanceof TreeNode)
1195                 old = (t = (TreeNode<K, V>) first).getTreeNode(hash, key);
1196             else {
1197                 Node<K, V> e = first;
1198                 K k;
1199                 do {
1200                     if (e.hash == hash &&
1201                             ((k = e.key) == key || (key != null && key.equals(k)))) {
1202                         old = e;
1203                         break;
1204                     }
1205                     ++binCount;
1206                 } while ((e = e.next) != null);
1207             }
1208         }
1209         if (old != null) {
1210             V v;
1211             if (old.value != null)
1212                 v = remappingFunction.apply(old.value, value);
1213             else
1214                 v = value;
1215             if (v != null) {
1216                 old.value = v;
1217                 afterNodeAccess(old);
1218             } else
1219                 removeNode(hash, key, null, false, true);
1220             return v;
1221         }
1222         if (value != null) {
1223             if (t != null)
1224                 t.putTreeVal(this, tab, hash, key, value);
1225             else {
1226                 tab[i] = newNode(hash, key, value, first);
1227                 if (binCount >= TREEIFY_THRESHOLD - 1)
1228                     treeifyBin(tab, hash);
1229             }
1230             ++modCount;
1231             ++size;
1232             afterNodeInsertion(true);
1233         }
1234         return value;
1235     }
1236 
1237     @Override
1238     public void forEach(BiConsumer<? super K, ? super V> action) {
1239         Node<K, V>[] tab;
1240         if (action == null)
1241             throw new NullPointerException();
1242         if (size > 0 && (tab = table) != null) {
1243             int mc = modCount;
1244             for (int i = 0; i < tab.length; ++i) {
1245                 for (Node<K, V> e = tab[i]; e != null; e = e.next)
1246                     action.accept(e.key, e.value);
1247             }
1248             if (modCount != mc)
1249                 throw new ConcurrentModificationException();
1250         }
1251     }
1252 
1253     @Override
1254     public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
1255         Node<K, V>[] tab;
1256         if (function == null)
1257             throw new NullPointerException();
1258         if (size > 0 && (tab = table) != null) {
1259             int mc = modCount;
1260             for (int i = 0; i < tab.length; ++i) {
1261                 for (Node<K, V> e = tab[i]; e != null; e = e.next) {
1262                     e.value = function.apply(e.key, e.value);
1263                 }
1264             }
1265             if (modCount != mc)
1266                 throw new ConcurrentModificationException();
1267         }
1268     }
1269 
1270     /* ------------------------------------------------------------ */
1271     // 克隆和序列化
1272 
1273     /**
1274      * 浅拷贝。
1275      * clone方法虽然生成了新的HashMap对象,新的HashMap中的table数组虽然也是新生成的,但是数组中的元素还是引用以前的HashMap中的元素。
1276      * 这就导致在对HashMap中的元素进行修改的时候,即对数组中元素进行修改,会导致原对象和clone对象都发生改变,但进行新增或删除就不会影响对方,因为这相当于是对数组做出的改变,clone对象新生成了一个数组。
1277      *
1278      * @return hashMap的浅拷贝
1279      */
1280     @SuppressWarnings("unchecked")
1281     @Override
1282     public Object clone() {
1283         HashMap<K, V> result;
1284         try {
1285             result = (HashMap<K, V>) super.clone();
1286         } catch (CloneNotSupportedException e) {
1287             // this shouldn't happen, since we are Cloneable
1288             throw new InternalError(e);
1289         }
1290         result.reinitialize();
1291         result.putMapEntries(this, false);
1292         return result;
1293     }
1294 
1295     // These methods are also used when serializing HashSets
1296     final float loadFactor() {
1297         return loadFactor;
1298     }
1299 
1300     final int capacity() {
1301         return (table != null) ? table.length :
1302                 (threshold > 0) ? threshold :
1303                         DEFAULT_INITIAL_CAPACITY;
1304     }
1305 
1306     /**
1307      * 序列化hashMap到ObjectOutputStream中
1308      * 将hashMap的总容量capacity、实际容量size、键值对映射写入到ObjectOutputStream中。键值对映射序列化时是无序的。
1309      *
1310      * @serialData The <i>capacity</i> of the HashMap (the length of the
1311      * bucket array) is emitted (int), followed by the
1312      * <i>size</i> (an int, the number of key-value
1313      * mappings), followed by the key (Object) and value (Object)
1314      * for each key-value mapping.  The key-value mappings are
1315      * emitted in no particular order.
1316      */
1317     private void writeObject(java.io.ObjectOutputStream s)
1318             throws IOException {
1319         int buckets = capacity();
1320         // Write out the threshold, loadfactor, and any hidden stuff
1321         s.defaultWriteObject();
1322         //写入总容量
1323         s.writeInt(buckets);
1324         //写入实际容量
1325         s.writeInt(size);
1326         //写入键值对
1327         internalWriteEntries(s);
1328     }
1329 
1330     /**
1331      * 到ObjectOutputStream中读取hashMap
1332      * 将hashMap的总容量capacity、实际容量size、键值对映射读取出来
1333      */
1334     private void readObject(java.io.ObjectInputStream s)
1335             throws IOException, ClassNotFoundException {
1336         // 将hashMap的总容量capacity、实际容量size、键值对映射读取出来
1337         s.defaultReadObject();
1338         //重置hashMap
1339         reinitialize();
1340         //如果加载因子不合法,抛出异常
1341         if (loadFactor <= 0 || Float.isNaN(loadFactor))
1342             throw new InvalidObjectException("Illegal load factor: " +
1343                     loadFactor);
1344         s.readInt();                //读出桶的数量,忽略
1345         int mappings = s.readInt(); //读出实际容量size
1346         //如果读出的实际容量size小于0,抛出异常
1347         if (mappings < 0)
1348             throw new InvalidObjectException("Illegal mappings count: " +
1349                     mappings);
1350         else if (mappings > 0) { // (if zero, use defaults)
1351             // Size the table using given load factor only if within
1352             // range of 0.25...4.0
1353             //调整hashMap大小
1354             float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);            // 加载因子
1355             float fc = (float) mappings / lf + 1.0f;         //初步得到的总容量,后续还会处理
1356             //处理初步得到的容量,确认最终的总容量
1357             int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
1358                     DEFAULT_INITIAL_CAPACITY :
1359                     (fc >= MAXIMUM_CAPACITY) ?
1360                             MAXIMUM_CAPACITY :
1361                             tableSizeFor((int) fc));
1362             //计算临界值,得到初步的临界值
1363             float ft = (float) cap * lf;
1364             //得到最终的临界值
1365             threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
1366                     (int) ft : Integer.MAX_VALUE);
1367 
1368             // Check Map.Entry[].class since it's the nearest public type to
1369             // what we're actually creating.
1370             SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
1371             //新建桶数组table
1372             @SuppressWarnings({"rawtypes", "unchecked"})
1373             Node<K, V>[] tab = (Node<K, V>[]) new Node[cap];
1374             table = tab;
1375 
1376             // 读出key和value,并组成键值对插入hashMap中
1377             for (int i = 0; i < mappings; i++) {
1378                 @SuppressWarnings("unchecked")
1379                 K key = (K) s.readObject();
1380                 @SuppressWarnings("unchecked")
1381                 V value = (V) s.readObject();
1382                 putVal(hash(key), key, value, false, false);
1383             }
1384         }
1385     }
1386 
1387     /* ------------------------------------------------------------ */
1388     // iterators
1389 
1390     abstract class HashIterator {
1391         Node<K, V> next;        // next entry to return
1392         Node<K, V> current;     // current entry
1393         int expectedModCount;  // for fast-fail
1394         int index;             // current slot
1395 
1396         HashIterator() {
1397             expectedModCount = modCount;
1398             Node<K, V>[] t = table;
1399             current = next = null;
1400             index = 0;
1401             if (t != null && size > 0) { // advance to first entry
1402                 do {
1403                 } while (index < t.length && (next = t[index++]) == null);
1404             }
1405         }
1406 
1407         public final boolean hasNext() {
1408             return next != null;
1409         }
1410 
1411         final Node<K, V> nextNode() {
1412             Node<K, V>[] t;
1413             Node<K, V> e = next;
1414             if (modCount != expectedModCount)
1415                 throw new ConcurrentModificationException();
1416             if (e == null)
1417                 throw new NoSuchElementException();
1418             if ((next = (current = e).next) == null && (t = table) != null) {
1419                 do {
1420                 } while (index < t.length && (next = t[index++]) == null);
1421             }
1422             return e;
1423         }
1424 
1425         public final void remove() {
1426             Node<K, V> p = current;
1427             if (p == null)
1428                 throw new IllegalStateException();
1429             if (modCount != expectedModCount)
1430                 throw new ConcurrentModificationException();
1431             current = null;
1432             K key = p.key;
1433             removeNode(hash(key), key, null, false, false);
1434             expectedModCount = modCount;
1435         }
1436     }
1437 
1438     final class KeyIterator extends HashIterator
1439             implements Iterator<K> {
1440         public final K next() {
1441             return nextNode().key;
1442         }
1443     }
1444 
1445     final class ValueIterator extends HashIterator
1446             implements Iterator<V> {
1447         public final V next() {
1448             return nextNode().value;
1449         }
1450     }
1451 
1452     final class EntryIterator extends HashIterator
1453             implements Iterator<Map.Entry<K, V>> {
1454         public final Map.Entry<K, V> next() {
1455             return nextNode();
1456         }
1457     }
1458 
1459     /* ------------------------------------------------------------ */
1460     // spliterators
1461 
1462     static class HashMapSpliterator<K, V> {
1463         final HashMap<K, V> map;
1464         Node<K, V> current;          //记录当前的节点
1465         int index;                  //当前节点的下标
1466         int fence;                  //堆大小
1467         int est;                    //估计大小
1468         int expectedModCount;       // for comodification checks
1469 
1470         HashMapSpliterator(HashMap<K, V> m, int origin,
1471                            int fence, int est,
1472                            int expectedModCount) {
1473             this.map = m;
1474             this.index = origin;
1475             this.fence = fence;
1476             this.est = est;
1477             this.expectedModCount = expectedModCount;
1478         }
1479 
1480         final int getFence() { // initialize fence and size on first use
1481             int hi;
1482             if ((hi = fence) < 0) {
1483                 HashMap<K, V> m = map;
1484                 est = m.size;
1485                 expectedModCount = m.modCount;
1486                 Node<K, V>[] tab = m.table;
1487                 hi = fence = (tab == null) ? 0 : tab.length;
1488             }
1489             return hi;
1490         }
1491 
1492         public final long estimateSize() {
1493             getFence(); // force init
1494             return (long) est;
1495         }
1496     }
1497 
1498     static final class KeySpliterator<K, V>
1499             extends HashMapSpliterator<K, V>
1500             implements Spliterator<K> {
1501         KeySpliterator(HashMap<K, V> m, int origin, int fence, int est,
1502                        int expectedModCount) {
1503             super(m, origin, fence, est, expectedModCount);
1504         }
1505 
1506         public KeySpliterator<K, V> trySplit() {
1507             int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
1508             return (lo >= mid || current != null) ? null :
1509                     new KeySpliterator<>(map, lo, index = mid, est >>>= 1,
1510                             expectedModCount);
1511         }
1512 
1513         public void forEachRemaining(Consumer<? super K> action) {
1514             int i, hi, mc;
1515             if (action == null)
1516                 throw new NullPointerException();
1517             HashMap<K, V> m = map;
1518             Node<K, V>[] tab = m.table;
1519             if ((hi = fence) < 0) {
1520                 mc = expectedModCount = m.modCount;
1521                 hi = fence = (tab == null) ? 0 : tab.length;
1522             } else
1523                 mc = expectedModCount;
1524             if (tab != null && tab.length >= hi &&
1525                     (i = index) >= 0 && (i < (index = hi) || current != null)) {
1526                 Node<K, V> p = current;
1527                 current = null;
1528                 do {
1529                     if (p == null)
1530                         p = tab[i++];
1531                     else {
1532                         action.accept(p.key);
1533                         p = p.next;
1534                     }
1535                 } while (p != null || i < hi);
1536                 if (m.modCount != mc)
1537                     throw new ConcurrentModificationException();
1538             }
1539         }
1540 
1541         public boolean tryAdvance(Consumer<? super K> action) {
1542             int hi;
1543             if (action == null)
1544                 throw new NullPointerException();
1545             Node<K, V>[] tab = map.table;
1546             if (tab != null && tab.length >= (hi = getFence()) && index >= 0) {
1547                 while (current != null || index < hi) {
1548                     if (current == null)
1549                         current = tab[index++];
1550                     else {
1551                         K k = current.key;
1552                         current = current.next;
1553                         action.accept(k);
1554                         if (map.modCount != expectedModCount)
1555                             throw new ConcurrentModificationException();
1556                         return true;
1557                     }
1558                 }
1559             }
1560             return false;
1561         }
1562 
1563         public int characteristics() {
1564             return (fence < 0 || est == map.size ? Spliterator.SIZED : 0) |
1565                     Spliterator.DISTINCT;
1566         }
1567     }
1568 
1569     static final class ValueSpliterator<K, V>
1570             extends HashMapSpliterator<K, V>
1571             implements Spliterator<V> {
1572         ValueSpliterator(HashMap<K, V> m, int origin, int fence, int est,
1573                          int expectedModCount) {
1574             super(m, origin, fence, est, expectedModCount);
1575         }
1576 
1577         public ValueSpliterator<K, V> trySplit() {
1578             int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
1579             return (lo >= mid || current != null) ? null :
1580                     new ValueSpliterator<>(map, lo, index = mid, est >>>= 1,
1581                             expectedModCount);
1582         }
1583 
1584         public void forEachRemaining(Consumer<? super V> action) {
1585             int i, hi, mc;
1586             if (action == null)
1587                 throw new NullPointerException();
1588             HashMap<K, V> m = map;
1589             Node<K, V>[] tab = m.table;
1590             if ((hi = fence) < 0) {
1591                 mc = expectedModCount = m.modCount;
1592                 hi = fence = (tab == null) ? 0 : tab.length;
1593             } else
1594                 mc = expectedModCount;
1595             if (tab != null && tab.length >= hi &&
1596                     (i = index) >= 0 && (i < (index = hi) || current != null)) {
1597                 Node<K, V> p = current;
1598                 current = null;
1599                 do {
1600                     if (p == null)
1601                         p = tab[i++];
1602                     else {
1603                         action.accept(p.value);
1604                         p = p.next;
1605                     }
1606                 } while (p != null || i < hi);
1607                 if (m.modCount != mc)
1608                     throw new ConcurrentModificationException();
1609             }
1610         }
1611 
1612         public boolean tryAdvance(Consumer<? super V> action) {
1613             int hi;
1614             if (action == null)
1615                 throw new NullPointerException();
1616             Node<K, V>[] tab = map.table;
1617             if (tab != null && tab.length >= (hi = getFence()) && index >= 0) {
1618                 while (current != null || index < hi) {
1619                     if (current == null)
1620                         current = tab[index++];
1621                     else {
1622                         V v = current.value;
1623                         current = current.next;
1624                         action.accept(v);
1625                         if (map.modCount != expectedModCount)
1626                             throw new ConcurrentModificationException();
1627                         return true;
1628                     }
1629                 }
1630             }
1631             return false;
1632         }
1633 
1634         public int characteristics() {
1635             return (fence < 0 || est == map.size ? Spliterator.SIZED : 0);
1636         }
1637     }
1638 
1639     static final class EntrySpliterator<K, V>
1640             extends HashMapSpliterator<K, V>
1641             implements Spliterator<Map.Entry<K, V>> {
1642         EntrySpliterator(HashMap<K, V> m, int origin, int fence, int est,
1643                          int expectedModCount) {
1644             super(m, origin, fence, est, expectedModCount);
1645         }
1646 
1647         public EntrySpliterator<K, V> trySplit() {
1648             int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
1649             return (lo >= mid || current != null) ? null :
1650                     new EntrySpliterator<>(map, lo, index = mid, est >>>= 1,
1651                             expectedModCount);
1652         }
1653 
1654         public void forEachRemaining(Consumer<? super Map.Entry<K, V>> action) {
1655             int i, hi, mc;
1656             if (action == null)
1657                 throw new NullPointerException();
1658             HashMap<K, V> m = map;
1659             Node<K, V>[] tab = m.table;
1660             if ((hi = fence) < 0) {
1661                 mc = expectedModCount = m.modCount;
1662                 hi = fence = (tab == null) ? 0 : tab.length;
1663             } else
1664                 mc = expectedModCount;
1665             if (tab != null && tab.length >= hi &&
1666                     (i = index) >= 0 && (i < (index = hi) || current != null)) {
1667                 Node<K, V> p = current;
1668                 current = null;
1669                 do {
1670                     if (p == null)
1671                         p = tab[i++];
1672                     else {
1673                         action.accept(p);
1674                         p = p.next;
1675                     }
1676                 } while (p != null || i < hi);
1677                 if (m.modCount != mc)
1678                     throw new ConcurrentModificationException();
1679             }
1680         }
1681 
1682         public boolean tryAdvance(Consumer<? super Map.Entry<K, V>> action) {
1683             int hi;
1684             if (action == null)
1685                 throw new NullPointerException();
1686             Node<K, V>[] tab = map.table;
1687             if (tab != null && tab.length >= (hi = getFence()) && index >= 0) {
1688                 while (current != null || index < hi) {
1689                     if (current == null)
1690                         current = tab[index++];
1691                     else {
1692                         Node<K, V> e = current;
1693                         current = current.next;
1694                         action.accept(e);
1695                         if (map.modCount != expectedModCount)
1696                             throw new ConcurrentModificationException();
1697                         return true;
1698                     }
1699                 }
1700             }
1701             return false;
1702         }
1703 
1704         public int characteristics() {
1705             return (fence < 0 || est == map.size ? Spliterator.SIZED : 0) |
1706                     Spliterator.DISTINCT;
1707         }
1708     }
1709 
1710     /* ------------------------------------------------------------ */
1711     // LinkedHashMap support
1712 
1713 
1714     /*
1715      * The following package-protected methods are designed to be
1716      * overridden by LinkedHashMap, but not by any other subclass.
1717      * Nearly all other internal methods are also package-protected
1718      * but are declared final, so can be used by LinkedHashMap, view
1719      * classes, and HashSet.
1720      */
1721 
1722     // 创建一个链表结点
1723     Node<K, V> newNode(int hash, K key, V value, Node<K, V> next) {
1724         return new Node<>(hash, key, value, next);
1725     }
1726 
1727     // 替换一个链表节点
1728     Node<K, V> replacementNode(Node<K, V> p, Node<K, V> next) {
1729         return new Node<>(p.hash, p.key, p.value, next);
1730     }
1731 
1732     // 创建一个红黑树节点
1733     TreeNode<K, V> newTreeNode(int hash, K key, V value, Node<K, V> next) {
1734         return new TreeNode<>(hash, key, value, next);
1735     }
1736 
1737     // 替换一个红黑树节点
1738     TreeNode<K, V> replacementTreeNode(Node<K, V> p, Node<K, V> next) {
1739         return new TreeNode<>(p.hash, p.key, p.value, next);
1740     }
1741 
1742     /**
1743      * Reset to initial default state.  Called by clone and readObject.
1744      */
1745     void reinitialize() {
1746         table = null;
1747         entrySet = null;
1748         keySet = null;
1749         values = null;
1750         modCount = 0;
1751         threshold = 0;
1752         size = 0;
1753     }
1754 
1755     // Callbacks to allow LinkedHashMap post-actions
1756     void afterNodeAccess(Node<K, V> p) {
1757     }
1758 
1759     void afterNodeInsertion(boolean evict) {
1760     }
1761 
1762     void afterNodeRemoval(Node<K, V> p) {
1763     }
1764 
1765     // 写入hashMap键值对到ObjectOutputStream中
1766     void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
1767         Node<K, V>[] tab;
1768         if (size > 0 && (tab = table) != null) {
1769             for (int i = 0; i < tab.length; ++i) {
1770                 for (Node<K, V> e = tab[i]; e != null; e = e.next) {
1771                     s.writeObject(e.key);
1772                     s.writeObject(e.value);
1773                 }
1774             }
1775         }
1776     }
1777 
1778     /* ------------------------------------------------------------ */
1779     // Tree bins
1780 
1781     /**
1782      * JDK1.8新增,用来支持桶的红黑树结构实现
1783      * 性质1. 节点是红色或黑色。
1784      * 性质2. 根是黑色。
1785      * 性质3. 所有叶子都是黑色(叶子是NIL节点)。
1786      * 性质4. 每个红色节点必须有两个黑色的子节点。(从每个叶子到根的所有路径上不能有两个连续的红色节点。)
1787      * 性质5. 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。
1788      */
1789 
1790     static final class TreeNode<K, V> extends LinkedHashMap.Entry<K, V> {
1791         TreeNode<K, V> parent;  //节点的父亲
1792         TreeNode<K, V> left;    //节点的左孩子
1793         TreeNode<K, V> right;   //节点的右孩子
1794         TreeNode<K, V> prev;    //节点的前一个节点
1795         boolean red;            //true表示红节点,false表示黑节点
1796 
1797         TreeNode(int hash, K key, V val, Node<K, V> next) {
1798             super(hash, key, val, next);
1799         }
1800 
1801         /**
1802          * 获取红黑树的根
1803          */
1804         final TreeNode<K, V> root() {
1805             for (TreeNode<K, V> r = this, p; ; ) {
1806                 if ((p = r.parent) == null)
1807                     return r;
1808                 r = p;
1809             }
1810         }
1811 
1812         /**
1813          * 确保root是桶中的第一个元素 ,将root移到中中的第一个
1814          */
1815         static <K, V> void moveRootToFront(Node<K, V>[] tab, TreeNode<K, V> root) {
1816             int n;
1817             if (root != null && tab != null && (n = tab.length) > 0) {
1818                 int index = (n - 1) & root.hash;
1819                 TreeNode<K, V> first = (TreeNode<K, V>) tab[index];
1820                 if (root != first) {
1821                     Node<K, V> rn;
1822                     tab[index] = root;
1823                     TreeNode<K, V> rp = root.prev;
1824                     if ((rn = root.next) != null)
1825                         ((TreeNode<K, V>) rn).prev = rp;
1826                     if (rp != null)
1827                         rp.next = rn;
1828                     if (first != null)
1829                         first.prev = root;
1830                     root.next = first;
1831                     root.prev = null;
1832                 }
1833                 assert checkInvariants(root);
1834             }
1835         }
1836 
1837         /**
1838          * 查找hash为h,key为k的节点
1839          */
1840         final TreeNode<K, V> find(int h, Object k, Class<?> kc) {
1841             TreeNode<K, V> p = this;
1842             do {
1843                 int ph, dir;
1844                 K pk;
1845                 TreeNode<K, V> pl = p.left, pr = p.right, q;
1846                 if ((ph = p.hash) > h)
1847                     p = pl;
1848                 else if (ph < h)
1849                     p = pr;
1850                 else if ((pk = p.key) == k || (k != null && k.equals(pk)))
1851                     return p;
1852                 else if (pl == null)
1853                     p = pr;
1854                 else if (pr == null)
1855                     p = pl;
1856                 else if ((kc != null ||
1857                         (kc = comparableClassFor(k)) != null) &&
1858                         (dir = compareComparables(kc, k, pk)) != 0)
1859                     p = (dir < 0) ? pl : pr;
1860                 else if ((q = pr.find(h, k, kc)) != null)
1861                     return q;
1862                 else
1863                     p = pl;
1864             } while (p != null);
1865             return null;
1866         }
1867 
1868         /**
1869          * 获取树节点,通过根节点查找
1870          */
1871         final TreeNode<K, V> getTreeNode(int h, Object k) {
1872             return ((parent != null) ? root() : this).find(h, k, null);
1873         }
1874 
1875         /**
1876          * 比较2个对象的大小
1877          */
1878         static int tieBreakOrder(Object a, Object b) {
1879             int d;
1880             if (a == null || b == null ||
1881                     (d = a.getClass().getName().
1882                             compareTo(b.getClass().getName())) == 0)
1883                 d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
1884                         -1 : 1);
1885             return d;
1886         }
1887 
1888         /**
1889          * 将链表转为二叉树
1890          *
1891          * @return root of tree
1892          */
1893         final void treeify(Node<K, V>[] tab) {
1894             TreeNode<K, V> root = null;
1895             for (TreeNode<K, V> x = this, next; x != null; x = next) {
1896                 next = (TreeNode<K, V>) x.next;
1897                 x.left = x.right = null;
1898                 if (root == null) {
1899                     x.parent = null;
1900                     x.red = false;
1901                     root = x;
1902                 } else {
1903                     K k = x.key;
1904                     int h = x.hash;
1905                     Class<?> kc = null;
1906                     for (TreeNode<K, V> p = root; ; ) {
1907                         int dir, ph;
1908                         K pk = p.key;
1909                         if ((ph = p.hash) > h)
1910                             dir = -1;
1911                         else if (ph < h)
1912                             dir = 1;
1913                         else if ((kc == null &&
1914                                 (kc = comparableClassFor(k)) == null) ||
1915                                 (dir = compareComparables(kc, k, pk)) == 0)
1916                             dir = tieBreakOrder(k, pk);
1917 
1918                         TreeNode<K, V> xp = p;
1919                         if ((p = (dir <= 0) ? p.left : p.right) == null) {
1920                             x.parent = xp;
1921                             if (dir <= 0)
1922                                 xp.left = x;
1923                             else
1924                                 xp.right = x;
1925                             root = balanceInsertion(root, x);
1926                             break;
1927                         }
1928                     }
1929                 }
1930             }
1931             moveRootToFront(tab, root);
1932         }
1933 
1934         /**
1935          * 将二叉树转为链表
1936          */
1937         final Node<K, V> untreeify(HashMap<K, V> map) {
1938             Node<K, V> hd = null, tl = null;
1939             for (Node<K, V> q = this; q != null; q = q.next) {
1940                 Node<K, V> p = map.replacementNode(q, null);
1941                 if (tl == null)
1942                     hd = p;
1943                 else
1944                     tl.next = p;
1945                 tl = p;
1946             }
1947             return hd;
1948         }
1949 
1950         /**
1951          * 添加一个键值对
1952          */
1953         final TreeNode<K, V> putTreeVal(HashMap<K, V> map, Node<K, V>[] tab,
1954                                         int h, K k, V v) {
1955             Class<?> kc = null;
1956             boolean searched = false;
1957             TreeNode<K, V> root = (parent != null) ? root() : this;
1958             for (TreeNode<K, V> p = root; ; ) {
1959                 int dir, ph;
1960                 K pk;
1961                 if ((ph = p.hash) > h)
1962                     dir = -1;
1963                 else if (ph < h)
1964                     dir = 1;
1965                 else if ((pk = p.key) == k || (k != null && k.equals(pk)))
1966                     return p;
1967                 else if ((kc == null &&
1968                         (kc = comparableClassFor(k)) == null) ||
1969                         (dir = compareComparables(kc, k, pk)) == 0) {
1970                     if (!searched) {
1971                         TreeNode<K, V> q, ch;
1972                         searched = true;
1973                         if (((ch = p.left) != null &&
1974                                 (q = ch.find(h, k, kc)) != null) ||
1975                                 ((ch = p.right) != null &&
1976                                         (q = ch.find(h, k, kc)) != null))
1977                             return q;
1978                     }
1979                     dir = tieBreakOrder(k, pk);
1980                 }
1981 
1982                 TreeNode<K, V> xp = p;
1983                 if ((p = (dir <= 0) ? p.left : p.right) == null) {
1984                     Node<K, V> xpn = xp.next;
1985                     TreeNode<K, V> x = map.newTreeNode(h, k, v, xpn);
1986                     if (dir <= 0)
1987                         xp.left = x;
1988                     else
1989                         xp.right = x;
1990                     xp.next = x;
1991                     x.parent = x.prev = xp;
1992                     if (xpn != null)
1993                         ((TreeNode<K, V>) xpn).prev = x;
1994                     moveRootToFront(tab, balanceInsertion(root, x));
1995                     return null;
1996                 }
1997             }
1998         }
1999 
2000         /**
2001          * Removes the given node, that must be present before this call.
2002          * This is messier than typical red-black deletion code because we
2003          * cannot swap the contents of an interior node with a leaf
2004          * successor that is pinned by "next" pointers that are accessible
2005          * independently during traversal. So instead we swap the tree
2006          * linkages. If the current tree appears to have too few nodes,
2007          * the bin is converted back to a plain bin. (The test triggers
2008          * somewhere between 2 and 6 nodes, depending on tree structure).
2009          */
2010         final void removeTreeNode(HashMap<K, V> map, Node<K, V>[] tab,
2011                                   boolean movable) {
2012             int n;
2013             if (tab == null || (n = tab.length) == 0)
2014                 return;
2015             int index = (n - 1) & hash;
2016             TreeNode<K, V> first = (TreeNode<K, V>) tab[index], root = first, rl;
2017             TreeNode<K, V> succ = (TreeNode<K, V>) next, pred = prev;
2018             if (pred == null)
2019                 tab[index] = first = succ;
2020             else
2021                 pred.next = succ;
2022             if (succ != null)
2023                 succ.prev = pred;
2024             if (first == null)
2025                 return;
2026             if (root.parent != null)
2027                 root = root.root();
2028             if (root == null || root.right == null ||
2029                     (rl = root.left) == null || rl.left == null) {
2030                 tab[index] = first.untreeify(map);  // too small
2031                 return;
2032             }
2033             TreeNode<K, V> p = this, pl = left, pr = right, replacement;
2034             if (pl != null && pr != null) {
2035                 TreeNode<K, V> s = pr, sl;
2036                 while ((sl = s.left) != null) // find successor
2037                     s = sl;
2038                 boolean c = s.red;
2039                 s.red = p.red;
2040                 p.red = c; // swap colors
2041                 TreeNode<K, V> sr = s.right;
2042                 TreeNode<K, V> pp = p.parent;
2043                 if (s == pr) { // p was s's direct parent
2044                     p.parent = s;
2045                     s.right = p;
2046                 } else {
2047                     TreeNode<K, V> sp = s.parent;
2048                     if ((p.parent = sp) != null) {
2049                         if (s == sp.left)
2050                             sp.left = p;
2051                         else
2052                             sp.right = p;
2053                     }
2054                     if ((s.right = pr) != null)
2055                         pr.parent = s;
2056                 }
2057                 p.left = null;
2058                 if ((p.right = sr) != null)
2059                     sr.parent = p;
2060                 if ((s.left = pl) != null)
2061                     pl.parent = s;
2062                 if ((s.parent = pp) == null)
2063                     root = s;
2064                 else if (p == pp.left)
2065                     pp.left = s;
2066                 else
2067                     pp.right = s;
2068                 if (sr != null)
2069                     replacement = sr;
2070                 else
2071                     replacement = p;
2072             } else if (pl != null)
2073                 replacement = pl;
2074             else if (pr != null)
2075                 replacement = pr;
2076             else
2077                 replacement = p;
2078             if (replacement != p) {
2079                 TreeNode<K, V> pp = replacement.parent = p.parent;
2080                 if (pp == null)
2081                     root = replacement;
2082                 else if (p == pp.left)
2083                     pp.left = replacement;
2084                 else
2085                     pp.right = replacement;
2086                 p.left = p.right = p.parent = null;
2087             }
2088 
2089             TreeNode<K, V> r = p.red ? root : balanceDeletion(root, replacement);
2090 
2091             if (replacement == p) {  // detach
2092                 TreeNode<K, V> pp = p.parent;
2093                 p.parent = null;
2094                 if (pp != null) {
2095                     if (p == pp.left)
2096                         pp.left = null;
2097                     else if (p == pp.right)
2098                         pp.right = null;
2099                 }
2100             }
2101             if (movable)
2102                 moveRootToFront(tab, r);
2103         }
2104 
2105         /**
2106          * 将结点太多的桶分割
2107          *
2108          * @param map   the map
2109          * @param tab   the table for recording bin heads
2110          * @param index the index of the table being split
2111          * @param bit   the bit of hash to split on
2112          */
2113         final void split(HashMap<K, V> map, Node<K, V>[] tab, int index, int bit) {
2114             TreeNode<K, V> b = this;
2115             // Relink into lo and hi lists, preserving order
2116             TreeNode<K, V> loHead = null, loTail = null;
2117             TreeNode<K, V> hiHead = null, hiTail = null;
2118             int lc = 0, hc = 0;
2119             for (TreeNode<K, V> e = b, next; e != null; e = next) {
2120                 next = (TreeNode<K, V>) e.next;
2121                 e.next = null;
2122                 if ((e.hash & bit) == 0) {
2123                     if ((e.prev = loTail) == null)
2124                         loHead = e;
2125                     else
2126                         loTail.next = e;
2127                     loTail = e;
2128                     ++lc;
2129                 } else {
2130                     if ((e.prev = hiTail) == null)
2131                         hiHead = e;
2132                     else
2133                         hiTail.next = e;
2134                     hiTail = e;
2135                     ++hc;
2136                 }
2137             }
2138 
2139             if (loHead != null) {
2140                 if (lc <= UNTREEIFY_THRESHOLD)
2141                     tab[index] = loHead.untreeify(map);
2142                 else {
2143                     tab[index] = loHead;
2144                     if (hiHead != null) // (else is already treeified)
2145                         loHead.treeify(tab);
2146                 }
2147             }
2148             if (hiHead != null) {
2149                 if (hc <= UNTREEIFY_THRESHOLD)
2150                     tab[index + bit] = hiHead.untreeify(map);
2151                 else {
2152                     tab[index + bit] = hiHead;
2153                     if (loHead != null)
2154                         hiHead.treeify(tab);
2155                 }
2156             }
2157         }
2158 
2159         /* ------------------------------------------------------------ */
2160         // 红黑树方法,都是从CLR中修改的
2161 
2162         /**
2163          * 左旋转
2164          *
2165          * @param root
2166          * @param p
2167          * @param <K>
2168          * @param <V>
2169          * @return
2170          */
2171         static <K, V> TreeNode<K, V> rotateLeft(TreeNode<K, V> root,
2172                                                 TreeNode<K, V> p) {
2173             TreeNode<K, V> r, pp, rl;
2174             if (p != null && (r = p.right) != null) {
2175                 if ((rl = p.right = r.left) != null)
2176                     rl.parent = p;
2177                 if ((pp = r.parent = p.parent) == null)
2178                     (root = r).red = false;
2179                 else if (pp.left == p)
2180                     pp.left = r;
2181                 else
2182                     pp.right = r;
2183                 r.left = p;
2184                 p.parent = r;
2185             }
2186             return root;
2187         }
2188 
2189         /**
2190          * 右旋转
2191          *
2192          * @param root
2193          * @param p
2194          * @param <K>
2195          * @param <V>
2196          * @return
2197          */
2198         static <K, V> TreeNode<K, V> rotateRight(TreeNode<K, V> root,
2199                                                  TreeNode<K, V> p) {
2200             TreeNode<K, V> l, pp, lr;
2201             if (p != null && (l = p.left) != null) {
2202                 if ((lr = p.left = l.right) != null)
2203                     lr.parent = p;
2204                 if ((pp = l.parent = p.parent) == null)
2205                     (root = l).red = false;
2206                 else if (pp.right == p)
2207                     pp.right = l;
2208                 else
2209                     pp.left = l;
2210                 l.right = p;
2211                 p.parent = l;
2212             }
2213             return root;
2214         }
2215 
2216         /**
2217          * 保证插入后平衡
2218          *
2219          * @param root
2220          * @param x
2221          * @param <K>
2222          * @param <V>
2223          * @return
2224          */
2225         static <K, V> TreeNode<K, V> balanceInsertion(TreeNode<K, V> root,
2226                                                       TreeNode<K, V> x) {
2227             x.red = true;
2228             for (TreeNode<K, V> xp, xpp, xppl, xppr; ; ) {
2229                 if ((xp = x.parent) == null) {
2230                     x.red = false;
2231                     return x;
2232                 } else if (!xp.red || (xpp = xp.parent) == null)
2233                     return root;
2234                 if (xp == (xppl = xpp.left)) {
2235                     if ((xppr = xpp.right) != null && xppr.red) {
2236                         xppr.red = false;
2237                         xp.red = false;
2238                         xpp.red = true;
2239                         x = xpp;
2240                     } else {
2241                         if (x == xp.right) {
2242                             root = rotateLeft(root, x = xp);
2243                             xpp = (xp = x.parent) == null ? null : xp.parent;
2244                         }
2245                         if (xp != null) {
2246                             xp.red = false;
2247                             if (xpp != null) {
2248                                 xpp.red = true;
2249                                 root = rotateRight(root, xpp);
2250                             }
2251                         }
2252                     }
2253                 } else {
2254                     if (xppl != null && xppl.red) {
2255                         xppl.red = false;
2256                         xp.red = false;
2257                         xpp.red = true;
2258                         x = xpp;
2259                     } else {
2260                         if (x == xp.left) {
2261                             root = rotateRight(root, x = xp);
2262                             xpp = (xp = x.parent) == null ? null : xp.parent;
2263                         }
2264                         if (xp != null) {
2265                             xp.red = false;
2266                             if (xpp != null) {
2267                                 xpp.red = true;
2268                                 root = rotateLeft(root, xpp);
2269                             }
2270                         }
2271                     }
2272                 }
2273             }
2274         }
2275 
2276         /**
2277          * 删除后调整平衡
2278          *
2279          * @param root
2280          * @param x
2281          * @param <K>
2282          * @param <V>
2283          * @return
2284          */
2285         static <K, V> TreeNode<K, V> balanceDeletion(TreeNode<K, V> root,
2286                                                      TreeNode<K, V> x) {
2287             for (TreeNode<K, V> xp, xpl, xpr; ; ) {
2288                 if (x == null || x == root)
2289                     return root;
2290                 else if ((xp = x.parent) == null) {
2291                     x.red = false;
2292                     return x;
2293                 } else if (x.red) {
2294                     x.red = false;
2295                     return root;
2296                 } else if ((xpl = xp.left) == x) {
2297                     if ((xpr = xp.right) != null && xpr.red) {
2298                         xpr.red = false;
2299                         xp.red = true;
2300                         root = rotateLeft(root, xp);
2301                         xpr = (xp = x.parent) == null ? null : xp.right;
2302                     }
2303                     if (xpr == null)
2304                         x = xp;
2305                     else {
2306                         TreeNode<K, V> sl = xpr.left, sr = xpr.right;
2307                         if ((sr == null || !sr.red) &&
2308                                 (sl == null || !sl.red)) {
2309                             xpr.red = true;
2310                             x = xp;
2311                         } else {
2312                             if (sr == null || !sr.red) {
2313                                 if (sl != null)
2314                                     sl.red = false;
2315                                 xpr.red = true;
2316                                 root = rotateRight(root, xpr);
2317                                 xpr = (xp = x.parent) == null ?
2318                                         null : xp.right;
2319                             }
2320                             if (xpr != null) {
2321                                 xpr.red = (xp == null) ? false : xp.red;
2322                                 if ((sr = xpr.right) != null)
2323                                     sr.red = false;
2324                             }
2325                             if (xp != null) {
2326                                 xp.red = false;
2327                                 root = rotateLeft(root, xp);
2328                             }
2329                             x = root;
2330                         }
2331                     }
2332                 } else { // symmetric
2333                     if (xpl != null && xpl.red) {
2334                         xpl.red = false;
2335                         xp.red = true;
2336                         root = rotateRight(root, xp);
2337                         xpl = (xp = x.parent) == null ? null : xp.left;
2338                     }
2339                     if (xpl == null)
2340                         x = xp;
2341                     else {
2342                         TreeNode<K, V> sl = xpl.left, sr = xpl.right;
2343                         if ((sl == null || !sl.red) &&
2344                                 (sr == null || !sr.red)) {
2345                             xpl.red = true;
2346                             x = xp;
2347                         } else {
2348                             if (sl == null || !sl.red) {
2349                                 if (sr != null)
2350                                     sr.red = false;
2351                                 xpl.red = true;
2352                                 root = rotateLeft(root, xpl);
2353                                 xpl = (xp = x.parent) == null ?
2354                                         null : xp.left;
2355                             }
2356                             if (xpl != null) {
2357                                 xpl.red = (xp == null) ? false : xp.red;
2358                                 if ((sl = xpl.left) != null)
2359                                     sl.red = false;
2360                             }
2361                             if (xp != null) {
2362                                 xp.red = false;
2363                                 root = rotateRight(root, xp);
2364                             }
2365                             x = root;
2366                         }
2367                     }
2368                 }
2369             }
2370         }
2371 
2372         /**
2373          * 检测是否符合红黑树
2374          */
2375         static <K, V> boolean checkInvariants(TreeNode<K, V> t) {
2376             TreeNode<K, V> tp = t.parent, tl = t.left, tr = t.right,
2377                     tb = t.prev, tn = (TreeNode<K, V>) t.next;
2378             if (tb != null && tb.next != t)
2379                 return false;
2380             if (tn != null && tn.prev != t)
2381                 return false;
2382             if (tp != null && t != tp.left && t != tp.right)
2383                 return false;
2384             if (tl != null && (tl.parent != t || tl.hash > t.hash))
2385                 return false;
2386             if (tr != null && (tr.parent != t || tr.hash < t.hash))
2387                 return false;
2388             if (t.red && tl != null && tl.red && tr != null && tr.red)
2389                 return false;
2390             if (tl != null && !checkInvariants(tl))
2391                 return false;
2392             if (tr != null && !checkInvariants(tr))
2393                 return false;
2394             return true;
2395         }
2396     }
2397 
2398 }

 

posted @ 2018-03-21 22:19  武培轩  阅读(1415)  评论(0编辑  收藏