java8的hashmap扩容机制

当put方法执行的时候，如果table为空，则执行resize();方法扩容。默认长度为16；

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

当table中存储值的个数大于等于threshold的时候，进行扩容。容量为原来的2倍。

   if (++size > threshold)
            resize();

计算索引位置

再默认的时候， hashcode为 5 和21 的值被存放在 索引为5的位置，但是再经过扩容后，21计算得的索引变为新数组的21处索引的位置。 由于在扩容中只用判断原来的 hash 值与左移动的一位（newtable 的值）按位与操作是 0 或 1 就行，0 的话索引就不变，1 的话索引变成原索引加上扩容前数组。感觉这个操作很是骚气。

hashCode	换算成二进制	容量为16	扩容为32
5	101	5	5
21	1 0101	5	21

代码注释

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) {
                //超过数组在java中最大容量就无能为力了，冲突就只能冲突
                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
            }
            //...... ......
            //更新新的最大容量为扩容计算后的最大容量
            threshold = newThr;
            //更新扩容后的新数组长度
            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;
                    //如果老数组对应索引上有元素则取出链表头元素放在e中
                    if ((e = oldTab[j]) != null) {
                        oldTab[j] = null;
                        //如果老数组j下标处只有一个元素则直接计算新数组中位置放置
                        if (e.next == null)
                            newTab[e.hash & (newCap - 1)] = e;
                        else if (e instanceof TreeNode)
                            //如果是树结构进行单独处理
                            ((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
                        else {
                            preserve order
                            //能进来说明数组索引j位置上存在哈希冲突的链表结构
                            Node<K, V> loHead = null, loTail = null;
                            Node<K, V> hiHead = null, hiTail = null;
                            Node<K, V> next;
                            //循环处理数组索引j位置上哈希冲突的链表中每个元素
                            do {
                                next = e.next;
                                //判断key的hash值与老数组长度与操作后结果决定元素是放在原索引处还是新索引
                                if ((e.hash & oldCap) == 0) {
                                    //放在原索引处的建立新链表
                                    if (loTail == null) loHead = e;
                                    else loTail.next = e;
                                    loTail = e;
                                } else {
                                    //放在新索引（原索引 + 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;
        }