一篇文章彻底读懂HashMap之HashMap源码解析(下)

//put函数入口,两个参数：key和value
public V put(K key, V value) {
    /*下面分析这个函数，注意前3个参数，后面
    2个参数这里不太重要，因为所有的put
    操作后面的2个参数默认值都一样 */
    return putVal(hash(key), key, 
              value, false, true);
    }
    
//下面是put函数的核心处理函数
final V putVal(int hash, K key, V value
               , boolean onlyIfAbsent
               ，boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; 
    int n, i;
    /*上面提到过HashMap是懒加载，所有
    put的时候要先检查table数组是否已经
    初始化了，没有初始化得先初始化table
    数组，保证table数组一定初始化了 */
    if ((tab = table) == null
       || (n = tab.length) == 0)
        //这个函数后面有resize函数分析
        n = (tab = resize()).length;

    /*到这里表示table数组一定初始化了
    与上面get函数相同，指定key的Node，
    会存储在在table数组的i=(n-1)&hash
    下标位置，get的时候也是从table数组
    的该位置搜索 */
    if ((p = tab[i = (n - 1) & hash])
         == null)
        /*如果i位置还没有存储元素，则把
        当前的key，value封装为Node，
        存储在table[i]位置  */
        tab[i] = newNode(hash, key
                    , value, null);
    else {
         //下面部分代码接上这部分
     }

/*
如果table[i]位置已经有元素了，
则接下来的流程是：
首先判断链表或者二叉树中是否
已经存在key的键值对?
存在的话就更新它的value；不存在
的话把当前的key，value插入到
链表的末尾或者插入到红黑树中
如果链表或者红黑树中已经存在
Node.key等于key，则e指向该Node，
即e指向一个Node：该Node的key属性
与put时传入的key参数相等的那个Node，
后面会更新e.value
 */

Node<K,V> e; K k;
/*
为什么get和put先判断p.hash==hash,
下面的if条件中去掉hash的比较逻辑
也是正确？因为hash的比较是两个整数
的比较，比较的代价相对较小，key是泛型，
对象的比较比整数比较代价大，所以先比较
hash，hash相等再比较key
*/
if(p.hash == hash &&
  ((k = p.key) == key 
  || (key != null
  && key.equals(k))))
  /*
  e指向一个Node：该Node的key
  属性与put时传入的key参数相等
  的那个Node
              */
      e = p;
 else if (p instanceof TreeNode)
    /*
    红黑树的插入操作，如果已经存在
    该key的TreeNode，则返回该
    TreeNode，否则返回null
     */
     e = ((TreeNode<K,V>)p)
         .putTreeVal(this
         , tab, hash, key, value);
 else {
 /*
 table[i]处存放的是链表，接下来和
 TreeNode类似在遍历链表过程中先判断
 当前的key是否已经存在，如果存在则令
 e指向该Node；否则将该Node插入到链
 表末尾，插入后判断链表长度是否>=8，
 是的话要进行额外操作
  */

     //binCountt最后的值是链表的长度
     for (int binCount = 0;
                  ;++binCount) {
         if ((e = p.next) == null) {
        /*
        遍历到了链表最后一个元素,接下来
        执行链表的插入操作，先封装为Node,
        再插入p指向的是链表最后一个节点，
        将待插入的Node置为p.next，
        就完成了单链表的插入
          */
             p.next = newNode(hash, key
                       , value, null);
             if (binCount 
                >= TREEIFY_THRESHOLD - 1)
             /*
             TREEIFY_THRESHOLD值是8,
             binCount>=7,然后又插入了一个新节
             点，链表长度>=8，这时要么进行扩容
             操作，要么把链表结构转为红黑树结构。
             我们接下会分析treeifyBin的源码实现
                                         */
             treeifyBin(tab, hash);
             break;
         }

         /*
          当p不是指向链表末尾的时候：先判断
          p.key是否等于key，等于的话表示
          当前key已经存在了，令e指向p，
          停止遍历，最后会更新e的value;
          不等的话准备下次遍历，
          令p=p.next，即p=e。 
                      */
         if (e.hash == hash &&
             ((k = e.key) == key 
             || (key != null
             && key.equals(k))))
             break;
         p = e;
     }
 }


 if (e != null) {
 /*
表示当前的key在put之前已经
存在了，并且上面的逻辑保证:
e已经指向了之前已经存在
的Node，这时更新
e.value就好。
      */

     //更新oldvalue
     V oldValue = e.value;

     /*
     onlyIfAbsent默是false，
     evict为true。
     onlyIfAbsent为true表示：
     如果之前已经存在key这个键值对了，
     那么后面再put这个key时，忽略这个
     操作，不更新先前的value。
     这里了解就好 
               */
     if (!onlyIfAbsent 
         || oldValue == null)
         //更新e.value
         e.value = value;

     /*
    这个函数的默认实现是“空”，
    即这个函数默认什么操作都
    不执行，那为什么要有它呢？
    这其实是个hook/钩子函数，
    主要要在LinkedHashMap
    （HashMap子类）中使用，
    LinkedHashMap重写了这
    个函数。以后会有讲解
    LinkedHashMap的文章。
             */
     afterNodeAccess(e);
     //返回旧的value
     return oldValue;
 }
 }

 //如果是第一次插入key这个键，
//就会执行到这里
 ++modCount;//failFast机制

 /*
 size保存的是当前HashMap中保存
 了多少个键值对，HashMap的size
 方法就是直接返回size之前说过，
 threshold保存的是当前table数
 组长度*loadfactor，如果table
 数组中存储的Node数量大于
 threshold，这时候会进行扩容，
 即将table数组的容量翻倍。
 后面会详细讲解resize方法。
   */
 if (++size > threshold)
     resize();

 //这也是一个hook函数，作用和
 //afterNodeAccess一样
     afterNodeInsertion(evict);
     return null;
 }  

//将链表转换为红黑树结构，在链表的
//插入操作后调用
final void treeifyBin
              (Node<K,V>[] tab
               , int hash) {
    int n, index; 
    Node<K,V> e;

    /*MIN_TREEIFY_CAPACITY值
    是64,也就是当链表长度>8的
    时候，有两种情况：如果table
    数组的长度<64,此时进行扩容
    操作;如果table数组的长度>64，
    此时进行链表转红黑树结构的操作.
    具体转细节在面试中几乎没有问的，
    这里不细讲了，大部同学认为链表长度
    >8一定会转换成红黑树，这是不对的！
    */
    if (tab == null || 
    (n = tab.length)
     < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e=tab[index=(n-1) 
                       & hash])
             != null) {
        TreeNode<K,V> hd = null, 
                      tl = null;
        do {
            TreeNode<K,V> p =
                replacementTreeNode(e
                , null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
} 

final Node<K,V>[] resize() {

    //保留扩容前数组引用
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) 
              ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //正常扩容：newCap = oldCap << 1
        else if ((newCap = oldCap << 1)
                 < MAXIMUM_CAPACITY 
                 && oldCap 
                 >= DEFAULT_INITIAL_CAPACITY)
            //容量翻倍，扩容后的threshold
            //自然也是*2
            newThr = oldThr << 1; 
    }
    else if (oldThr > 0) 
    // initial capacity was placed 
    //in threshold
       newCap = oldThr;
    else {
       // zero initial threshold 
       //signifies  using defaults
       //table数组初始化的时候会进入到这里
  
       //默认容量
        newCap = DEFAULT_INITIAL_CAPACITY;
        //threshold
        newThr = (int)(DEFAULT_LOAD_FACTOR
               * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        float ft = (float)newCap*loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY 
        && ft < (float)MAXIMUM_CAPACITY ?
               (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;//更新threshold
    @SuppressWarnings({"rawtypes"
                 ,"unchecked"})
    //扩容后的新数组
    Node<K,V>[] newTab = (Node<K,V>[])
                         new Node[newCap];
    table = newTab;//执行容量翻倍的新数组
    if (oldTab != null) {
    //之后完成oldTab中Node迁移到table中去
            //见下面
            }
        }
    }
    return newTab;
}    
}

//之后完成oldTab中Node迁移到table中去
for (int j = 0; j < oldCap; ++j) {
    Node<K,V> e;
    if ((e = oldTab[j]) != null) {
        oldTab[j] = null;
        if (e.next == null)
        /*j这个桶位置只有一个元素，直接
        rehash到table数组 */
            newTab[e.hash 
                  & (newCap - 1)] = e;
        else if (e instanceof TreeNode)
      /*如果是红黑树：也是将红黑树拆分为
      两个链表，这里主要看链表的拆分，
      两者逻辑一样*/
            ((TreeNode<K,V>)e).split(
            this, newTab, j, oldCap);
        else { 
            //链表的拆分
            //第一个链表l1
            Node<K,V> loHead = null
                    , loTail = null;

            //第二个链表l2
            Node<K,V> hiHead = null
                      , hiTail = null;
            Node<K,V> next;
            do {
                next = e.next;
                if ((e.hash & oldCap)
                    == 0) {
                /*rehash到table[j]位置
                将当前node连接到l1上  */
                    if (loTail == null)
                        loHead = e;
                    else
                        loTail.next = e;
                    loTail = e;
                }
                else {
                  //将当前node连接到l2上
                    if (hiTail == null)
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                }
            } while ((e = next) != null);

            if (loTail != null) {
                //l1放到table[j]位置
                loTail.next = null;
                newTab[j] = loHead;
            }
            if (hiTail != null) {
           //l1放到table[j+oldCap]位置
                hiTail.next = null;
                newTab[j + oldCap] = hiHead;
            }
        }
    }
}

if (map.containsKey(k)) {
   return map.get(k);
} else {
   throw new KeyNotPresentException();
}