HashMap源码

tableSizeFor

    返回大于等于输入参数且最接近2的整数次幂。数组长度必须为2的整数次幂就是可以根据hash快速的定位对象所属的位置。
    哈希桶长度常规设计是为素数，因为素数可以减少碰撞的产生。HashTable的哈希桶的初始大小就是11。

    static final int tableSizeFor(int cap) {
        //防止传入的就是2的整数次幂的数
        int n = cap - 1;
        
        //假如n为: 001*(1前面可以有任意个数的0，*表示任意个任意数)
        //n >>> 1 -> n变为 0001*
        //n |= n  -> n变为 0011*
        n |= n >>> 1;
        //这个时候已经保证n从最高位开始至少是两个1连续，所以可以移位操作两位
        //n变为 001111*
        n |= n >>> 2;
        //n变为 0011111111*
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        //这个时候已经可以保证n为 001111类似的样子(1的数目可以是任意一个)

        //加一之后就会变为2的整数次幂的数
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

hash

    static final int hash(Object key) {
       int h;
       //int是32位存储的数据，右位移16位，正好是32位的一半
       //自己的高半区和低半区做异或，既加大了低位的随机性（减少碰撞的产生），又可以在低位中保留高位的信息
       //毕竟数组的长度不会太长，hash的高位数据几乎没用
       
       //计算hash的目的就是获取key在数组中的下标，由于数组的长度为2的整数次幂
       //数组长度减一之后就变为类似001111类的样子(1的数目可以是任意一个)，这就是数组长度必须为2的整数次幂的原因
       //把数组长度减一和返回结果做与的操作，可以直接获得key在数组中的位置
       return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
   }

getNode

    判断是否存在和get()底层都是调用此方法。

    final Node<K, V> getNode(int hash, Object key) {
       Node<K, V>[] tab;
       Node<K, V> first, e;
       int n;
       K k;
       if ((tab = table) != null && (n = tab.length) > 0 &&
               (first = tab[(n - 1) & hash]) != null) {
           if (first.hash == hash && // always check first node
                   ((k = first.key) == key || (key != null && key.equals(k))))
               return first;
           if ((e = first.next) != null) {
               if (first instanceof HashMap.TreeNode)
                   //已经转换为红黑树
                   return ((HashMap.TreeNode<K, V>) first).getTreeNode(hash, key);
               //没有转换为红黑树，遍历查询key
               do {
                   if (e.hash == hash &&
                           ((k = e.key) == key || (key != null && key.equals(k))))
                       return e;
               } while ((e = e.next) != null);
           }
       }
       return null;
   }

removeNode

    final Node<K, V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
       Node<K, V>[] tab;
       Node<K, V> p;
       int n, index;
       if ((tab = table) != null && (n = tab.length) > 0 &&
               //从最后一个开始查询
               (p = tab[index = (n - 1) & hash]) != null) {
           Node<K, V> node = null, e;
           K k;
           V v;
           if (p.hash == hash &&
                   ((k = p.key) == key || (key != null && key.equals(k))))
               //验证是否是最后一个
               node = p;
           else if ((e = p.next) != null) {
               if (p instanceof HashMap.TreeNode)
                   //已经转换为红黑树
                   node = ((HashMap.TreeNode<K, V>) p).getTreeNode(hash, key);
               else {
                   //没有转换为红黑树，遍历查询key
                   do {
                       if (e.hash == hash &&
                               ((k = e.key) == key ||
                                       (key != null && key.equals(k)))) {
                           node = e;
                           break;
                       }
                       //p是要删除node的上一个
                       p = e;
                   } while ((e = e.next) != null);
               }
           }
           if (node != null && (!matchValue || (v = node.value) == value ||
                   (value != null && value.equals(v)))) {
               if (node instanceof HashMap.TreeNode)
                   //是红黑树
                   ((HashMap.TreeNode<K, V>) node).removeTreeNode(this, tab, movable);
               else if (node == p)
                   tab[index] = node.next;
               else
                   //p是要删除node的上一个
                   p.next = node.next;
               ++modCount;
               --size;
               //HashMap中是个空白方法，在LinkedHashMap中维护双向链表
               afterNodeRemoval(node);
               return node;
           }
       }
       return null;
   }

putVal

    put()方法调用的就是这个方法。

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                  boolean evict) {
       HashMap.Node<K, V>[] tab;
       HashMap.Node<K, V> p;
       int n, i;
       if ((tab = table) == null || (n = tab.length) == 0)
           //哈希桶数组还没有建立，建立新的哈希桶数组
           n = (tab = resize()).length;
       if ((p = tab[i = (n - 1) & hash]) == null)//p为哈希桶对应位置的第一个数据
           //对应的哈希桶数组是空的，对象就是第一个数据
           tab[i] = newNode(hash, key, value, null);
       else {
           HashMap.Node<K, V> e;
           K k;
           if (p.hash == hash &&
                   ((k = p.key) == key || (key != null && key.equals(k))))
               //要加的数据的key已经存在，直接覆盖
               e = p;
           else if (p instanceof HashMap.TreeNode)
               //对应位置是红黑树
               e = ((HashMap.TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
           else {
               //对应位置是链表，遍历链表
               for (int binCount = 0; ; ++binCount) {
                   //直到链表的最后
                   if ((e = p.next) == null) {
                       //把数据添加到链表的最后一位
                       p.next = newNode(hash, key, value, null);

                       //链表的长度到达8，需要转换为红黑树
                       if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                           treeifyBin(tab, hash);
                       break;
                   }

                   //要加的数据的key已经存在，直接覆盖
                   if (e.hash == hash &&
                           ((k = e.key) == key || (key != null && key.equals(k))))
                       break;
                   p = e;
               }
           }
           if (e != null) { // existing mapping for key
               V oldValue = e.value;
               if (!onlyIfAbsent || oldValue == null)
                   e.value = value;
               afterNodeAccess(e);
               return oldValue;
           }
       }
       ++modCount;
       if (++size > threshold)
           //如果数据的数量到了极限数据，就要扩容
           resize();
       //为其子类LinkedHashMap准备
       afterNodeInsertion(evict);
       return null;
   }

resize

    如果扩容之后红黑树的结点数量小于7，红黑树就会重新转换位链表。

    /**
    * 由于HashMap每次都是扩容成为原来的2被，在数据迁移计算老数据在新的哈希桶的位置的时候
    * 不需要重新计算哈希定位，例如hash=1101 oldCap=16(1000) newCap=32
    * 原来计算对象在哈希桶的位置是：hash & (oldCap-1) 即：1101 & 0111 结果为：101
    * 当cap变为32的时候，决定对象在哈希桶的位置就由原来的后三位改为后四位，所以关键就在新加的第四位
    * 如果hash值的第四位是0，那么位置是和原先是一样的；如果为1，就相当于原先的位置+oldCap
    * 所以迁移数据计算的方式可以简化为：(hash & (oldCap)) * oldCap + 原来的位置
    * 而且新加的第四位可以说是随机的，正好可以把原先的数据均匀的分布在新的哈希桶数组中。
    */
   final HashMap.Node<K, V>[] resize() {
       HashMap.Node<K, V>[] oldTab = table;
       int oldCap = (oldTab == null) ? 0 : oldTab.length;
       int oldThr = threshold;
       int newCap, newThr = 0;

       //计算新的哈希桶的长度和HashMap的threshold
       if (oldCap > 0) {
           //最大容量就是 1 << 30，每次都是上次的2倍
           if (oldCap >= MAXIMUM_CAPACITY) {
               threshold = Integer.MAX_VALUE;
               return oldTab;
           } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                   oldCap >= DEFAULT_INITIAL_CAPACITY)
               newThr = oldThr << 1; // double threshold
       } else if (oldThr > 0) // initial capacity was placed in threshold
           //原先指定了threshold
           //原先没有建立哈希桶数组，建立默认容量的哈希桶数组
           newCap = oldThr;
       else {               // zero initial threshold signifies using defaults
           //原来没有指定threshold也没有建立哈希桶数组，全部默认初始化
           newCap = DEFAULT_INITIAL_CAPACITY;
           newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
       }
       //在 0<oldCap<DEFAULT_INITIAL_CAPACITY的时候，threshold = newCap * loadFactor;
       if (newThr == 0) {
           float ft = (float) newCap * loadFactor;
           newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
                   (int) ft : Integer.MAX_VALUE);
       }
       threshold = newThr;
       @SuppressWarnings({"rawtypes", "unchecked"})
       HashMap.Node<K, V>[] newTab = (HashMap.Node<K, V>[]) new HashMap.Node[newCap];
       table = newTab;

       //把老数据迁移到新的哈希桶里
       if (oldTab != null) {
           for (int j = 0; j < oldCap; ++j) {
               HashMap.Node<K, V> e;
               //e为旧的哈希桶数据上的第一个
               if ((e = oldTab[j]) != null) {
                   oldTab[j] = null;
                   if (e.next == null)
                       //旧的哈希桶数据上面只有一个
                       newTab[e.hash & (newCap - 1)] = e;
                   else if (e instanceof HashMap.TreeNode)
                       //旧的哈希桶数据上面是一个红黑树，原理几乎和链表一样
                       ((HashMap.TreeNode<K, V>) e).split(this, newTab, j, oldCap);
                   else { // preserve order
                       //旧的哈希桶数据上面是一个链表，链表长度大于1
                       HashMap.Node<K, V> loHead = null, loTail = null;
                       HashMap.Node<K, V> hiHead = null, hiTail = null;
                       HashMap.Node<K, V> next;
                       //根据新增位将旧的哈希桶上的一个链表分为两个
                       do {
                           next = e.next;
                           if ((e.hash & oldCap) == 0) {
                               //新增位为0，位置不变
                               if (loTail == null)
                                   loHead = e;
                               else
                                   loTail.next = e;
                               loTail = e;
                           } else {
                               //新增位为1，位置加上oldCap
                               if (hiTail == null)
                                   hiHead = e;
                               else
                                   hiTail.next = e;
                               hiTail = e;
                           }
                       } while ((e = next) != null);
                       //将新生成的两个链表放到对应的位置上
                       if (loTail != null) {
                           loTail.next = null;
                           newTab[j] = loHead;
                       }
                       if (hiTail != null) {
                           hiTail.next = null;
                           newTab[j + oldCap] = hiHead;
                       }
                   }
               }
           }
       }
       return newTab;
   }

balanceInsertion

rotateLeft

rotateRight

treeifyBin

moveRootToFront

treeifyBin

    final void treeifyBin(HashMap.Node<K, V>[] tab, int hash) {
       int n, index;
       HashMap.Node<K, V> e;
       //如果哈希桶为空或者长度小于64，就会认为没有必要转换位红黑树，扩容就可以
       if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
           resize();
       else if ((e = tab[index = (n - 1) & hash]) != null) {
           HashMap.TreeNode<K, V> hd = null, tl = null;
           do {
               //把e转换位TreeNode类型
               HashMap.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);
       }
   }