HashMap底层分析

HashMap集合的数据结构-存储过程

HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put("张三",18);
hashMap.put("李四",18);
hashMap.put("张三",20);

1、当创建HashMap集合对象时，在jdk1.8之前，构造方法中创建了一个 长度为16的Entry[] table 用来存储键值对数据；在jdk1.8之后，不是在构造方法底层创建数组了，而是在第一次调用put()方法时创建的数组 Node[] table 来存储键值对数据。

2、假设向哈希表中存储张三-18数据，根据张三调用String类重写后的hashcode()方法计算出hash值，然后用结合数组长度采用某种算法计算出向Node[]数组中存储数据的空间的索引值，如果计算出的索引空间没有数据，则直接将张三-18存到数组中。

3、假设李四的hashcode()值与张三一样，那么此时的索引空间不为null，此时底层会比较张三和李四的hash值是否一致，如果不一致，则在此空间上划分出一个节点来存储李四-18。这种方法叫做拉链法。

4、向哈希表中存储张三-20，此时hashcode()得到的索引值和前面的张三一样。此时比较后存储的张三的hash值和已经存在的数据的hash值是否一致，不一致，则采取拉链法添加元素，一致则发生哈希碰撞。
发生哈希碰撞后，底层会调用张三的所属类String中的equals()方法比较两个内容是否相等：
（1）相等。将后添加数据的value覆盖之前的value。
（2）不相等。那么继续与链表中的其他数据进行比较，如果全部都不相等，则划分一个节点存储数据。

如果节点长度即链表长度大于阈值8并且数组长度大于64则，将链表变成红黑树。节点长度即链表长度大于阈值8并且数组长度小于64，则进行数组扩容。

哈希表底层采用的何种算法计算hash值？还有哪些算法可以计算？ 底层采用的是key的hashCode方法的值结合数组长度进行无符号右移(>>>)、按位异或(^)、按位与(&)。 还可以采用：平方取中法、取余法、伪随机数法。

1、HashMap存取值原理

put()方法

• jdk1.7存值分析

private void inflateTable(int toSize) {
    // 将大小调整为2的n次方（12 -> 16）
    int capacity = roundUpToPowerOf2(toSize);

    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity);
}

public V put(K key, V value) {
	if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    //HashMap允许存储null键，存储在数组的0索引位置
    if (key == null)
        return putForNullKey(value);
    //内部通过一个扰乱算法获得一个hash值，用于计算数组索引
    int hash = hash(key);
    //计算数组索引
    int i = indexFor(hash, table.length);
    //判断是否是重复键
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    //添加元素
    addEntry(hash, key, value, i);
    return null;
}

void addEntry(int hash, K key, V value, int bucketIndex) {
    //元素个数大于阈值，同时当前索引位有值，就会执行扩容操作
    if ((size >= threshold) && (null != table[bucketIndex])) {
        //2倍扩容
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        //重新计算索引位置
        bucketIndex = indexFor(hash, table.length);
    }
	//基于键值创建Entry节点，并以头插法存入对应位置
    createEntry(hash, key, value, bucketIndex);
}

• jdk1.8

public V put(K key, V value) {
    //hash(key)计算hash值，用于计算索引
    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;
    //完成初始化容器
    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;
        //重复键
        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 {
            //遍历链表依次比较键
            for (int binCount = 0; ; ++binCount) {
                //没有重复键
                if ((e = p.next) == null) {
                    //尾插法，添加元素，形成单向链表
                    p.next = newNode(hash, key, value, null);
                    //树化
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //有重复键
                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();
    afterNodeInsertion(evict);
    return null;
}

get()方法

• jdk1.7

public V get(Object key) {
	//取空键对应的值
    if (key == null)
        return getForNullKey();
    //取非空键对应的值
    Entry<K,V> entry = getEntry(key);

    return null == entry ? null : entry.getValue();
}

   final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }

        int hash = (key == null) ? 0 : hash(key);
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

• jdk1.8

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

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 TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                //链表查找
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

2、HashMap如何防止碰撞

解决hash碰撞的方式有很多，比如开放地址法，重哈希，链地址法，公共溢出区等等。

HashMap中防止碰撞的方式主要有两个：哈希值扰动+链地址法（当扰动后，还是hash碰撞，使用链表/红黑树存储元素）

• jdk1.7扰动

final int hash(Object k) {
    int h = 0;
    h ^= k.hashCode();
    //充分利用高低位
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}
 01100011 00001110 11000110 00011001
 00000000 01101010 11001100 00011001

• jdk1.8扰动

static final int hash(Object key) {
     int h;
     //充分利用高低位
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }

3、HashMap容量取值问题

• jdk1.7默认容量

public HashMap() {
    //默认容量16
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}

• jdk1.7自定义容量

public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
    //超过最大容纳量，取最大容量
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    //负载因子容错处理
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
    this.loadFactor = loadFactor;
    //这个阈值不是真正的阈值，后面在put()的时候会调用inflateTable
    threshold = initialCapacity;
    init();
}

• jdk1.8容量赋值
• 注意，jdk1.8的容量计算动作，在resize()扩容方法中完成。

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;
        }
        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;

• jdk1.8中容量计算：

static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

cap = 12
二进制 
00000000 00000000 00000000 00001100
cap - 1
00000000 00000000 00000000 00001011
n |= n >>> 1:
00000000 00000000 00000000 00001011
00000000 00000000 00000000 00000101
-----------------------------------
00000000 00000000 00000000 00001111

n |= n >>> 2:
00000000 00000000 00000000 00001111
00000000 00000000 00000000 00000111
-----------------------------------
00000000 00000000 00000000 00001111

....
最终结果：00000000 00000000 00000000 00001111 = 15
返回 16

• 通过一系列右移+或运算后，能够将初始值减一得到的值，后面的所有0变成1，最终返回的是得到的值+1的结果作为容量，正好就是大于等于给定容量的2的幂次方数

4、HashMap数据结构（1.7和1.8对比）

• jdk1.7数据结构：数组+单向链表

void createEntry(int hash, K key, V value, int bucketIndex) {
    //取出索引位置的元素
    Entry<K,V> e = table[bucketIndex];
    //将新的元素放置到索引位，同时将原来的作为新元素的下一个保存，形成单向链表
    //头插法
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

• jdk1.8数据结构：数组+单向链表+红黑树+双向链表
  只看 红黑树和双向链表结构

//当添加元素后，单向链表长度达到8个会执行该方法
final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    //如果此时数组长度小于64，会通过扩容数组的方式，来避免单向链表过长
    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 {
            //把所有Node节点，转成TreeNode节点，并形成双向链表
            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);
    }
}

//当添加元素时，对应的索引位置为TreeNode节点，会执行该方法
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                               int h, K k, V v) {
    Class<?> kc = null;
    boolean searched = false;
    TreeNode<K,V> root = (parent != null) ? root() : this;
    for (TreeNode<K,V> p = root;;) {
        int dir, ph; K pk;
        if ((ph = p.hash) > h)
            dir = -1;
        else if (ph < h)
            dir = 1;
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p;
        else if ((kc == null &&
                  (kc = comparableClassFor(k)) == null) ||
                 (dir = compareComparables(kc, k, pk)) == 0) {
            if (!searched) {
                TreeNode<K,V> q, ch;
                searched = true;
                if (((ch = p.left) != null &&
                     (q = ch.find(h, k, kc)) != null) ||
                    ((ch = p.right) != null &&
                     (q = ch.find(h, k, kc)) != null))
                    return q;
            }
            dir = tieBreakOrder(k, pk);
        }
		//以上逻辑，就是在遍历红黑树，决定新元素放置的位置
        TreeNode<K,V> xp = p;
        if ((p = (dir <= 0) ? p.left : p.right) == null) {
            Node<K,V> xpn = xp.next;
            TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
            //找到新元素放置的位置，并将其添加进红黑树结构
            if (dir <= 0)
                xp.left = x;
            else
                xp.right = x;
            //同时维护双向链表结构
            xp.next = x;
            x.parent = x.prev = xp;
            if (xpn != null)
                ((TreeNode<K,V>)xpn).prev = x;
            //通过变色+旋转达到红黑树的自平衡
            moveRootToFront(tab, balanceInsertion(root, x));
            return null;
        }
    }
}

• 在维护红黑树的同时，还维护了一种双向链表的结构呢，主要是为了扩容方便的

5、HashMap扩容时机及扩容机制

• jdk1.7扩容：先扩容，在添加值

void addEntry(int hash, K key, V value, int bucketIndex) {
    //当元素个数达到了扩容阈值，同时元素该放置的位置有元素时，会执行扩容
    if ((size >= threshold) && (null != table[bucketIndex])) {
        //扩容为原来的两倍
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    //扩容之后，在将新元素添加进集合
    createEntry(hash, key, value, bucketIndex);
}

void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    //达到最大容量，不扩容
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
    Entry[] newTable = new Entry[newCapacity];
    transfer(newTable, initHashSeedAsNeeded(newCapacity));
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    for (Entry<K,V> e : table) {
        while(null != e) {
            //记录遍历到的元素的下一个元素
            Entry<K,V> next = e.next;
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            //计算新数组的角标位置
            int i = indexFor(e.hash, newCapacity);
            //把当前元素的下一个改为新数组对应位置的元素--头插法
            e.next = newTable[i];
            //将当前元素放置在数组对应索引位置
            newTable[i] = e;
            //再次迁移下一个元素
            e = next;
        }
    }
}

• jdk1.8扩容：先添加值，再扩容

//元素个数，达到扩容阈值，就扩容
//这个方法前半部分初始化数组的逻辑之前已经分析过了
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;
        }
        //新的数组容量为原来的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) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                //数组角标位置只有一个元素，直接将数据迁移到新数组
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                //数组角标位置为TreeNode，迁移红黑树数据
                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;
                        //放置在原来角标位置的元素
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                //尾插法
                                loTail.next = e;
                            loTail = e;
                        }
                        //放置在原来角标+扩容容量 位置的元素
                        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;
}

• 红黑树数据的迁移

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
    TreeNode<K,V> b = this;
    // Relink into lo and hi lists, preserving order
    TreeNode<K,V> loHead = null, loTail = null;
    TreeNode<K,V> hiHead = null, hiTail = null;
    int lc = 0, hc = 0;
    //通过遍历双向链表，实现数据迁移
    for (TreeNode<K,V> e = b, next; e != null; e = next) {
        next = (TreeNode<K,V>)e.next;
        e.next = null;
        //原角标位置
        if ((e.hash & bit) == 0) {
            //记录前一个
            if ((e.prev = loTail) == null)
                loHead = e;
            else
                //记录下一个 -- 尾插法
                loTail.next = e;
            loTail = e;
            //该标记累计，用于判断是否需要转会单向链表
            ++lc;
        }
        //原角标+扩容容量 位置
        else {
            //记录前一个
            if ((e.prev = hiTail) == null)
                hiHead = e;
            else
                //记录下一个 -- 尾插法
                hiTail.next = e;
            hiTail = e;
            //该标记累计，用于判断是否需要转会单向链表
            ++hc;
        }
    }

    if (loHead != null) {
        //元素个数小于等于6，转成单向链表
        if (lc <= UNTREEIFY_THRESHOLD)
            tab[index] = loHead.untreeify(map);
        else {
            //存入新的数组
            tab[index] = loHead;
            if (hiHead != null) // (else is already treeified)
                //树化
                loHead.treeify(tab);
        }
    }
    if (hiHead != null) {
        //元素个数小于等于6，转成单向链表
        if (hc <= UNTREEIFY_THRESHOLD)
            tab[index + bit] = hiHead.untreeify(map);
        else {
            //存入新的数组
            tab[index + bit] = hiHead;
            if (loHead != null)
                //树化
                hiHead.treeify(tab);
        }
    }
}

//将红黑树转成单向链表
final Node<K,V> untreeify(HashMap<K,V> map) {
    Node<K,V> hd = null, tl = null;
    for (Node<K,V> q = this; q != null; q = q.next) {
        Node<K,V> p = map.replacementNode(q, null);
        if (tl == null)
            hd = p;
        else
            //尾插法，形成单向链表
            tl.next = p;
        tl = p;
    }
    return hd;
}

6、多线程下HashMap扩容的问题（1.7和1.8对比）

• jdk1.7，多线程扩容情况下，会导致循环引用
• jdk1.8，多线程环境下，会导致数据丢失问题

// 添加元素时，会有数据覆盖丢失数据
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; 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)
        tab[i] = newNode(hash, key, value, null);
    
    //下面代码省略

// 扩容时，迁移数据的情况下，会有数据覆盖丢失的问题
// 多线程环境下，给同一个数组的相同位置赋值，会有数据覆盖的风险
if (loTail != null) {
    loTail.next = null;
    newTab[j] = loHead;  //将原始索引位的数据迁移到新数组
}
if (hiTail != null) {
    hiTail.next = null;
    newTab[j + oldCap] = hiHead; //将新索引位的数据迁移到新数组
}

当然，jdk1.8中的HashMap本身是线程不安全的，在多线程环境下使用ConcurrentHashMap

面试题

1.HashMap的数据结构？

• 在JDK1.7中HashMap的底层数据结构是Entry数组+链表实现的，JDK1.8中是Node数组+链表+红黑树。Entry和Node都实现了Map.Entry接口，里面的成员都有key、value、next指针和hash，HashMap通过put()和get()方法来存储和获取数据。
• 发生哈希冲突时，JDK1.7用的是头插法，而JDK1.8及之后使用的都是尾插法，当采用头插法时会容易出现逆序且环形链表死循环问题，在JDK1.8之后是因为加入了红黑树使用尾插法，能够避免出现逆序且链表死循环的问题。

2.那你讲一下put()的具体过程吧，以JDK8为例

• put()的时候，首先会看数组是否已经初始化？没有则通过resize()初始化table，接下来根据hash & 数组长度 - 1得到该元素在数组中的下标，如该位置为null，则直接new 一个Node放在该位置即可，插入完毕。
• 如果是有元素，则发生了哈希冲突。比较他们的hash和key是不是一样，一样则说明是一个替换操作，直接替换即可。
• 否则，判断该元素是不是属于TreeNode，是，则按红黑树的插入方式。
• 都不是，则说明是链表，根据next指针向后遍历该链表，直到找到和他key一样的，说明是替换操作，不然直到node为null，则插入链表末尾。如果插入后链表数量大于8，则进行树化treeifyBin操作。
• 插入结束后，判断table的size > 扩容阈值吗？大于则进行扩容，不然就结束了。

讲一下HashMap的get()过程

• get()方法通过计算指定key的哈希值后，调用内部方法 getNode()；
• getNode()方法中根据 hash & tab.length-1 计算出对应索引位置，如果hash和key都一样，则找到，直接返回
• 不然说明有哈希冲突。判断头节点是不是是红黑树节点，是，就调用红黑树节点的getTreeNode()方法，其实就是TreeNode类中的find()方法。
• 否则就遍历链表节点，结束！

说一下HashMap的扩容机制？

发生扩容的情况：

1.第一次put（）的时候，这个时候数组还是空的，初始化数组大小默认16，负载因子0.75，阈值12
2.还有在链表长度大于8，table的长度小于64时，是不进行树化的，而是扩容数组
3.这个就是数组的size 大于 阈值了， 需要扩容

扩容过程：

真正在resize()方法里面,创建一个newTable，大小老表的2倍。主要是要进行一个老表数据迁移到newTable中，会去遍历老表中的数据，分四种情况；
（1）该table[i] == null, 没有迁移的数据
（2）table[i] != null, 并且table[i] = null, 也就是说只有一个头节点，这样就按照hash & newTab.length - 1得到下标，直接放到newTable中
（3）该节点属于TreeNode，按红黑树的 方式插入
（4）链表情况：JDK8会分为两种情况：高位链 和 低位链
就是计算 e.hash & oldCap = 0 ？ 放在和老表一样的位置 ： 放在老表位置 + 老表长度 （原因：我们知道计算元素下标的方式是 e.hash & table.length - 1, 数组扩容变为原来数组的2倍， 比如说 老表长度为16， 16-1=15 二进制就是 0000 1111, 新表长度为32， 32-1=31， 它的二进制就是 比 15多一个1，0001 1111, 这样计算e.hash & 31 和 e.hash & 15结果就只和高位那个1有关， 如果e.hash & 16(0001 0000) = 0 ，说明e.hash & 31高位不影响它的结果，所以计算的下标和原来的一样；e.hash & 16(0001 0000) = 1，说明2.hash的倒数第五位就是1， 那么计算得到的下标就是 在原有的基础上 + 10000，也就是老表下标 + 老表长度）