HashMap基础

常量

• static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
  • 默认初始容量为16
• static final int MAXIMUM_CAPACITY = 1 << 30;
  • 最大容量为2的30次方
• static final float DEFAULT_LOAD_FACTOR = 0.75f;
  • 默认负载因子为0.75
• static final int TREEIFY_THRESHOLD = 8;
  • 链表长度为8时转化为红黑树
• static final int UNTREEIFY_THRESHOLD = 6;
  • 红黑树节点数为6时转化为链表
• static final int MIN_TREEIFY_CAPACITY = 64;
  • 容量最少要到64才会把链表转为红黑树

成员变量

• transient Node<K,V>[] table:
  • node节点组成的数组
  • Node：节点内存有 key、value、hash值、next指针（指向下一个Node节点，以此形成链表解决哈希冲突）
• transient int size
  • map已有元素数量
• transient int modCount
  • map被更新的次数，迭代器的快速失败依赖于该字段。
  • 迭代器快速失败： 新建迭代器时，迭代器会记录下当前的modCount，每次迭代时会查看map的modCount和新建时记录的是否一致，不一致则说明map在迭代过程中被更新过会直接抛出异常结束迭代
• int threshold
  • map元素数量超过该值则会扩容
• final float loadFactor
  • 负载因子
• transient Set<Map.Entry<K,V>> entrySet;

构造方法

• public HashMap()
• public HashMap(int initialCapacity)
• public HashMap(int initialCapacity, float loadFactor)
• public HashMap(Map<? extends K, ? extends V> m)

我们能设置的值：初始容量大小、负载因子
- HashMap的容量一定是2的n次幂，所以当初入参值不为2的n次幂时，始容量大小为大于入参值的最小2的n次幂
- 如果需要put的key-value很多，且我们知道总的key-value的数量，那么可以在新建HashMap设置初始容量为总数减少扩容的次数以提升性能

put方法

put方法是HashMap最复杂也是最关键的核心流程，只要梳理清楚put的逻辑，那么HashMap的原理也就基本都捋清楚了，所以我们直接开始一次put方法的深度源码解析之旅，go~

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

    static final int hash(Object key) {
        int h;
        // 1、key允许为null，并对其进行了特殊处理
        // 2、key==null时hash值设置为0，所以key==null时，有且仅有可能放在第一个桶内
        // 3、hash值的计算方式：hashCode值的高16位异或hashCode值，这样产生的hash值会比较随机
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    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没有初始化，则进行初始化（resize方法）
        if ((tab = table) == null || (n = tab.length) == 0) 
            n = (tab = resize()).length;
        // 如果分配到的哈希桶为空，直接插入
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
        	// 代码如果进入这里，说明这个哈希桶里已经有值了，即发生了哈希冲突
            Node<K,V> e; K k;
            // 如果key和桶的第一个节点相等
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 如果这个桶内的节点已经转为了红黑树
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
            	// 代码进入到这里，需要遍历链表看key是否已经存在
                for (int binCount = 0; ; ++binCount) {
                	// 如果e为null，说明链表已经遍历完，但没有相同的key，则在尾部插入新节点
                    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，e就是该节点
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // e如果bu为null，说明key早已存在，只是更新value不需要新增节点
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        // 更新次数+1
        ++modCount;
        // 如果map大小已经到达阈值，则执行扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

计算key对应哈希桶位置的公式为 hash & (cap - 1)
cap（容量）为2的n次方，例如16，二进制表示为 10000，则16 - 1 二进制表示为 01111
hash & 01111 即为只读取hash值的低4位即为该key对应的哈希桶的位置
同理得容量为32时，即读取hash值的低5位即为该key在32个桶时对应哈希桶的位置
每次扩容时都会多读一位，新增加的最高位只有两种可能， 0 或 1
如果为0，则位置不变
如果为1则位置为原桶的位置+原table容量大小
基于这个原理，扩容时如果桶内只有一个节点，那么可以直接重新哈希插入，不会发生哈希冲突
如果桶内是一个链表，则分成两批，一批留在原桶位置，另一批挪到新桶

    final Node<K,V>[] resize() {
    	// 旧table
        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;
            }
            // 新容量为旧容量*2，新阈值为旧阈值*2（左移计算性能高）
            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
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            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;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
        	// 遍历旧table的每个哈希桶
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                // 如果这个桶不为空，则需要复制桶内的节点到新table
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    // 如果桶内只有一个节点，重新哈希分配到新table的哈希桶内
                    // （小问题：为什么这里是直接赋值，不会发生哈希冲突吗？暂且按下不表）
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    // 如果这个节点是红黑树节点，则切分红黑树，如果红黑树节点过少（6个）则会转为链表
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                    	// 代码到这里，说明桶内是一个链表，分成两批，整个过程不需要考虑哈希冲突，性能高
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            // 新读取最高位如果是0，说明该节点留在原位置
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            // 新读取最高位如果是1，说明该节点挪到在原位置 + oldCap
                            else {
                                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;
    }