hashmap源码分析jdk8

最近看了下jdk8的hashmap源码，相比于7，在存储结构上有了些改变。

1.在jdk8之前，hashmap的存储结构是数组+链表的形式，那么这种方式随着链表的长度增加，效率也凸显出来。

所以在jdk8中这块做了优化，当链表超过一定长度时转化为红黑树来解决这个问题，下面用流程图画出hashmap

的put方法实现逻辑。

下面请带着这些问题看源码，为什么树的查找效率比链表高，达到什么样的条件会扩容，为什么扩容会影响效率

呢，怎样实现链表到树的转化？

2.先来看下put方法源码。

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {

        Node<K,V>[] tab; Node<K,V> p; int n, i;

        //如果table为空，则创建一个table

        if ((tab = table) == null || (n = tab.length) == 0)

            n = (tab = resize()).length;

       //确定插入table的位置，算法是(n - 1) & hash

        if ((p = tab[i = (n - 1) & hash]) == null)

            tab[i] = newNode(hash, key, value, null);

       //在table的i位置发生碰撞，有两种情况，1、key值是一样的，替换value值，

      //2、key值不一样的有两种处理方式：2.1、存储在i位置的链表；2.2、存储在红黑树中

        else {

            Node<K,V> e; K k;

// 如果hash、key都相等，直接覆盖

            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))

                e = p;

    //2.2

            else if (p instanceof TreeNode)

                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

           //2.1

            else {

//开始遍历链表

                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {

                        p.next = newNode(hash, key, value, null);

//如果冲突节点超过8调用treeifyBin转化成红黑树

                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;

                    }

                   //如果链表上的值出现hash，key和待插入的值相等，则退出循环。

                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;//将p调整为下一个节点
                }

            }

            //如果e非空就替换旧的oldValue值

            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }

        ++modCount;

       //threshold=newThr:(int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //默认0.75*16，大于threshold值就扩容

        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;

    }

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

  2      Node<K,V>[] oldTab = table;

  3      int  oldCap = (oldTab ==  null ) ?  0  : oldTab.length;

  4      int  oldThr = threshold;

  5      int  newCap, newThr =  0 ;

  6      if  (oldCap >  0 ) {

  7          // 超过最大值就不再扩充了，就只好随你碰撞去吧

  8          if  (oldCap >= MAXIMUM_CAPACITY) {

  9              threshold = Integer.MAX_VALUE;

10              return  oldTab;

11          }

12          // 没超过最大值，就扩充为原来的2倍

13          else  if  ((newCap = oldCap <<  1 ) < MAXIMUM_CAPACITY &&

14                   oldCap >= DEFAULT_INITIAL_CAPACITY)

15              newThr = oldThr <<  1 ;  // double threshold

16      }

17      else  if  (oldThr >  0 )  // initial capacity was placed in threshold

18          newCap = oldThr;

19      else  {                // zero initial threshold signifies using defaults

20          newCap = DEFAULT_INITIAL_CAPACITY;

21          newThr = ( int )(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

22      }

23      // 计算新的resize上限

24      if  (newThr ==  0 ) {

25

26          float  ft = ( float )newCap * loadFactor;

27          newThr = (newCap < MAXIMUM_CAPACITY && ft < ( float )MAXIMUM_CAPACITY ?

28                    ( int )ft : Integer.MAX_VALUE);

29      }

30      threshold = newThr;

31      @SuppressWarnings ({ "rawtypes" ， "unchecked" })

32          Node<K,V>[] newTab = (Node<K,V>[]) new  Node[newCap];

33      table = newTab;

34      if  (oldTab !=  null ) {

35          // 把每个bucket都移动到新的buckets中

36          for  ( int  j =  0 ; j < oldCap; ++j) {

37              Node<K,V> e;

38              if  ((e = oldTab[j]) !=  null ) {

39                  oldTab[j] =  null ;

40                  if  (e.next ==  null )

41                      newTab[e.hash & (newCap -  1 )] = e;

42                  else  if  (e  instanceof  TreeNode)

43                      ((TreeNode<K,V>)e).split( this , newTab, j, oldCap);

44                  else  {  // 链表优化重hash的代码块

45                      Node<K,V> loHead =  null , loTail =  null ;

46                      Node<K,V> hiHead =  null , hiTail =  null ;

47                      Node<K,V> next;

48                      do  {

49                          next = e.next;

50                          // 原索引

51                          if  ((e.hash & oldCap) ==  0 ) {

52                              if  (loTail ==  null )

53                                  loHead = e;

54                              else

55                                  loTail.next = e;

56                              loTail = e;

57                          }

58                          // 原索引+oldCap

59                          else  {

60                              if  (hiTail ==  null )

61                                  hiHead = e;

62                              else

63                                  hiTail.next = e;

64                              hiTail = e;

65                          }

66                      }  while  ((e = next) !=  null );

67                      // 原索引放到bucket里

68                      if  (loTail !=  null ) {

69                          loTail.next =  null ;

70                          newTab[j] = loHead;

71                      }

72                      // 原索引+oldCap放到bucket里

73                      if  (hiTail !=  null ) {

74                          hiTail.next =  null ;

75                          newTab[j + oldCap] = hiHead;

76                      }

77                  }

78              }

79          }

80      }

81      return  newTab;

82  }