深入理解HashMap的扩容机制

深入理解HashMap的扩容机制

 

——原创：转载请注明出处 http://www.cnblogs.com/yanzige/p/8392142.html

注：本文分两部分讲解，第一部分讲解Java7，第二部分讲解Java8 

 

Java 7 中Hashmap扩容机制

 

一、什么时候扩容：

网上总结的会有很多，但大多都总结的不够完整或者不够准确。大多数可能值说了满足我下面条件一的情况。

扩容必须满足两个条件：

1、 存放新值的时候当前已有元素的个数必须大于等于阈值

2、 存放新值的时候当前存放数据发生hash碰撞（当前key计算的hash值换算出来的数组下标位置已经存在值）

 

二、下面我们看源码，如下：

首先是put()方法

public V put(K key, V value) {
　　　　//判断当前Hashmap(底层是Entry数组)是否存值（是否为空数组）
　　　　if (table == EMPTY_TABLE) {
　　　　　　inflateTable(threshold);//如果为空，则初始化
　　　　}
　　　　
　　　　//判断key是否为空
　　　　if (key == null)
　　　　　　return putForNullKey(value);//hashmap允许key为空
　　　　
　　　　//计算当前key的哈希值　　　　
　　　　int hash = hash(key);
　　　　//通过哈希值和当前数据长度，算出当前key值对应在数组中的存放位置
　　　　int i = indexFor(hash, table.length);
　　　　for (Entry<K,V> e = table[i]; e != null; e = e.next) {
　　　　　　Object k;
　　　　　　//如果计算的哈希位置有值（及hash冲突），且key值一样，则覆盖原值value，并返回原值value
　　　　　　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;
　　}

　　　

在put()方法中有调用addEntry()方法，这个方法里面是具体的存值，在存值之前还要判断是否需要扩容

void addEntry(int hash, K key, V value, int bucketIndex) {
　　　　//1、判断当前个数是否大于等于阈值
　　　　//2、当前存放是否发生哈希碰撞
　　　　//如果上面两个条件否发生，那么就扩容
　　　　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);
　　}

贴上Entry类的源码

 static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;// 通过next构成一个单向链表
        int hash;

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
｝

　　

如果需要扩容，调用扩容的方法resize()

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()方法把原数组中的值放到新数组中
　　　　transfer(newTable, initHashSeedAsNeeded(newCapacity));
　　　　//设置hashmap扩容后为新的数组引用
　　　　table = newTable;
　　　　//设置hashmap扩容新的阈值
　　　　threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
　　}

transfer()在实际扩容时候把原来数组中的元素放入新的数组中

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);
　　　　　　　　}
　　　　　　　　//通过key值的hash值和新数组的大小算出在当前数组中的存放位置
　　　　　　　　int i = indexFor(e.hash, newCapacity);
　　　　　　　　e.next = newTable[i];
　　　　　　　　newTable[i] = e;
　　　　　　　　e = next;
　　　　　　}
　　　　}
　　}

JDK7版本及以前使用是：头插法（对比JDK8使用的是尾插法）

注：使用头插法在多线程扩容的时候可能会导致循环指向，从而在获取数据get()的时候陷入死循环，到是线程执行无法结束

头插法：有点类似于砌墙的砖头后来居上的感觉，先插入的会被逐步放到最底下，越后来的会被放在头部，并将next指针指向之前的头部，这样在扩容的时候，先取头部然后把头部放到新对应数组下标的链表处，由于头插法，最早取的会被最先放进并逐步变成最尾，如果多线程执行扩容，将数组下标3位置链表存入的A->B->C扩容时存入到新的数组（假设扩容后A/B/C还在同一个链表上），线程1取第一个元素A被挂起的时候，挂起的元素A元素的next指向B，而线程2放入新的链表时，A被先放但没有完成，线程2在放入B后，B的next指向之前放入的A，当线程1执行的时候本身A的next指向B，这样就行程了循环引用，最后存入C，并将C的next指向B，最终就变成C->B-><-A，在get()方法执行到该数组下标时，遍历链表查找的时候就会出现死循环。

尾插法：元素插入的时候都是从尾部插入，这样新进来的就在头部，后进来的就在尾部，扩容的时候，先进来的先出，指向next和扩容前方向一致，所以不存在循环指向的问题。

JDK7存入元素到同一个数组下标位置的链表处，每次存入的新元素是在链表的头部：

    HashMap map = new HashMap<Integer,Integer>(16);
    map.put(1,1);
    map.put(16,2);
    map.put(35,3);
    map.put(50,4);
    map.put(69,5);
    map.put(84,6);
    map.put(103,7);
    map.put(136,8);
    map.put(153,9);
    map.put(170,10);
    map.put(187,11);
    map.put(204,12);
    map.put(221,13);    

如上面代码，在前12个元素存入数字下标为1的位置，那么链表是如下构成

 

源码解读：

public V put(K key, V value) {

        // ...省略很多源码，看红色的方法

        modCount++;
        addEntry(hash, key, value, i);// i为上面省略处计算的数组下标
        return null;
}

    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 createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex]; // bucketIndex 为数组下标，第一个元素进来的收那么 table[下标位置]=null,所以对应代码 put(1,1) 上图node第一个节点的 next 就为空
        table[bucketIndex] = new Entry<>(hash, key, value, e);// e表示上一个节点，将上一个节点放到新节点的next处——》并且将新new Entry对象给到当前table[数组下标位置]
        size++;
    }

所以这个过程下来，新节点就在链表的头部位置，最早被加入的Entry节点在最尾的位置。

三、总结：

Hashmap的扩容需要满足两个条件：当前数据存储的数量（即size()）大小必须大于等于阈值；当前加入的数据是否发生了hash冲突。

因为上面这两个条件，所以存在下面这些情况

（1）、就是hashmap在存值的时候（默认大小为16，负载因子0.75，阈值12），可能达到最后存满16个值的时候，再存入第17个值才会发生扩容现象，因为前16个值，每个值在底层数组中分别占据一个位置，并没有发生hash碰撞。

（2）、当然也有可能存储更多值（超多16个值，最多可以存27个值）都还没有扩容。原理：前11个值全部hash碰撞，存到数组的同一个位置（虽然hash冲突，但是这时元素个数小于阈值12，并没有同时满足扩容的两个条件。所以不会扩容），[在存入第12个元素的时候，还是存入前面11个元素所在的下标位置，因为存入之前此时比较当前元素个数 11<12(16*0.75)，所以在存入第12个元素的时候不会发生扩容，那么还有15个数据下标的位置是空的，后面所有存入的15个值全部分散到数组剩下的15个位置（这时元素个数大于等于阈值，但是每次存入的元素并没有发生hash碰撞，也没有同时满足扩容的两个条件，所以叶不会扩容），前面11+15=26（12+15=27评论指正，20201230日晚验证后修改为27），所以在存入第28个值的时候才同时满足上面两个条件，这时候才会发生扩容现象。

---------------------------------------------------------------------------- 2020年3月25号 更新下 ---------------------------------------------------------------------------- 

Java 8 中Hashmap扩容机制

 

一、Java8的扩容机制：

　　Java8不再像Java7中那样需要满足两个条件，Java8中扩容只需要满足一个条件：当前存放新值（注意不是替换已有元素位置时）的时候已有元素的个数大于等于阈值（已有元素等于阈值，下一个存放后必然触发扩容机制）

　　注：

　　（1）扩容一定是放入新值的时候，该新值不是替换以前位置的情况下（说明：put（“name”,"zhangsan"），而map里面原有数据<"name","lisi">，则该存放过程就是替换一个原有值，而不是新增值，则不会扩容）

　　（2）扩容发生在存放后，即是数据存放后（先存放后扩容），判断当前存入对象的个数，如果大于阈值则进行扩容。

二、背静知识：

　　Java7中Hashmap底层采用的是Entry对数组，而每一个Entry对又向下延伸是一个链表，在链表上的每一个Entry对不仅存储着自己的key/value值，还存了一个当前对象的hash值和指向下一个地址的next Node节点。

　　Java8中的Hashmap底层结构有一定的变化，还是使用的数组，但是数组的对象以前是Entry对，现在换成了Node对象（可以理解是Entry对，结构一样，存储时也会存key/value键值对、当前对象的hash值和指向下一个地址的next Node节点），以前所有的Entry向下延伸都是链表，Java8变成链表和红黑树的组合，数据少量存入的时候优先还是链表，当链表长度大于8，且数组长度大于64的时候，链表就会转化成红黑树，所以你会看到Java8的Hashmap的数据存储是数组+链表+红黑树的组合，如果数组长度小于64则只有数组+链表，如果数组长度大于64，且某一个数组下标数据量大于8，那么该处即为红黑树。

贴上Node类的源码

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;// 和JDK7中的Entry一样，都是通过next来构建单向链表

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
        // 下面省略该类的一些方法，主要是看上面的内部结构     
｝    

三、源码：

　　在JDK7中，当new Hashmap()的时候会对对象进行初始化，而JDK8中new Hashmap()并没有对对象进行初始化，而是在put()方法中通过判断对象是否为空，如果为空通过调用resize()来初始化对象。

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

    /**
     * Implements Map.put and related methods
     *
     * @param hash key值计算传来的下标
     * @param key
     * @param value
     * @param onlyIfAbsent true只是在值为空的时候存储数据，false都存储数据
     * @param evict
     * @return 返回被覆盖的值，如果没有覆盖则返回null
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        // 申明entry数组对象tab[]:当前Entry[]对象
        Node<K,V>[] tab;
        // 申明entry对象p:这里表示存放的单个节点
        Node<K,V> p;
        // n:为当前Entry对象长度 
　　　　 // i:为当前存放对象节点的位置下标
        int n, i;

        /**
         * 流程判断
         * 1、如果当前Node数组(tab)为空，则直接创建(通过resize()创建)，并将当前创建后的长度设置给n
         * 2、如果要存放对象所在位置的Node节点为空，则直接将对象存放位置创建新Node，并将值直接存入
         * 3、存放的Node数组不为空，且存放的下标节点Node不为空（该Node节点为链表的首节点）
         *   1）比较链表的首节点存放的对象和当前存放对象是否为同一个对象，如果是则直接覆盖并将原来的值返回
         *   2）如果不是分两种情况
         *      （1）存储处节点为红黑树node结构，调用方法putTreeVal()直接将数据插入
         *      （2）不是红黑树，则表示为链表，则进行遍历
         *          A.如果在链表中不存在key相同的node节点，则直接将该值存入链表尾部的空节点，存入后检查当前存入位置是否已经大于链表的第8个位置
         *              a.如果大于,调用treeifyBin方法判断是扩容 还是 需要将该链表转红黑树（大于8且数组长度大于64则转红黑色，否则对数组进行扩容）
         *              b.当前存入位置链表长度没有大于8，则存入成功，结束循环操作。
         *          B.如果存入链表的下一个位置有值，且该key和存入对象“一样”，在for循环中直接break,将给key相同的node节点赋值给e，在外面做统一处理
         *          上面AB两种情况执行完成后，判断返回的原对象是否为空，如果不为空，则将原对象的原始value返回
         * 上面123三种情况下，如果没有覆盖原值，则表示新增存入数据，存储数据完成后，size+1,然后判断当前数据量是否大于阈值，
         * 如果大于阈值，则进行扩容。
         */
        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) {
　　　　　　　　　　　　// for循环中有两个if,如果没有key相同（第二个if没有break）,那么表示遍历完了链表直接将值插入链表尾部（尾插法使用p.next=newNode()）
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);//该方法判断是扩容还是需要将该链表转红黑树
                        break;
                    }
　　　　　　　　　　　　// 如果存入链表的下一个位置有值，且该key和存入对象“一样”，直接break,将给key相同的node节点赋值给e(在上一步if中已经赋值了)，在外面做统一处理
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
　　　　　　　　　　　　// 每遍历一次在第一个if((e=p.next) == null)中从头到尾将每一个Node()节点复制给e,然后再将e赋值给p,使得链表完成从头到尾的遍历过程
                    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;
        // 如果不是替换数据存入，而是新增位置存入后，则将map的size进行加1，然后判断容量是否超过阈值，超过则扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

　　treeifyBin()方法判断是扩容还是将当前链表转红黑树

    /**
     * Replaces all linked nodes in bin at index for given hash unless
     * table is too small, in which case resizes instead.
     * 从指定hash位置处的链表nodes头部开始，全部替换成红黑树结构。
     * 除非整个数组对象（Map集合）数据量很小（数组长度小于64），该情况下则通过resize()对这个Map进行扩容，而代替将链表转红黑树的操作。
     */
    final void treeifyBin(HashMap.Node<K,V>[] tab, int hash) {
        int n, index; HashMap.Node<K,V> e;
        // 如果Map（数组）为空或者当前存入数据数组长度小于64便进行扩容
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        // 如果数组长度大于64则将正在存入的该值所在的链表转化成红黑树
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            HashMap.TreeNode<K,V> hd = null, tl = null;
            do {
                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);
        }
    }

四、总结：

　　（1）Java 8 在新增数据存入成功后进行扩容

　　（2）扩容会发生在两种情况下（满足任意一种条件即发生扩容）：

　　　　　　a 当前存入数据大于阈值即发生扩容

　　　　　　b 存入数据到某一条链表时，此时该链表数据个数大于8，且数组长度小于64即发生扩容

　　（3）此外需要注意一点java7是在存入数据前进行判断是否扩容，而java8是在存入数据后再进行扩容的判断。

ConcurrentHashMap知识参考：https://www.cnblogs.com/zerotomax/p/8687425.html

Java8 HashMap扩容可参考：https://blog.csdn.net/goosson/article/details/81029729 （注：该文章中关于Java8 底层数据结构描述不准确，只有当数组长度大于64才会有红黑树+链表）

这里补充一下JDK8关于红黑树和链表的知识：

　　第一次添加元素的时候，默认初期长度为16，当往map中继续添加元素的时候，通过hash值跟数组长度取“与”来决定放在数组的哪个位置，如果出现放在同一个位置的时候，优先以链表的形式存放，在同一个位置的个数又达到了8个（代码是>=7,从0开始，及第8个开始判断是否转化成红黑树），如果数组的长度还小于64的时候，则会扩容数组。如果数组的长度大于等于64的话，才会将该节点的链表转换成树。在扩容完成之后，如果某个节点的是树，同时现在该节点的个数又小于等于6个了，则会将该树转为链表。