HashMap从Put()方法源码分析扩容机制

HashMap从源码分析扩容机制

Put方法

put(key,value)代码：

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

hash(key)代码：

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

可以看出HashMap中用到的hash值并不是直接调用Object的hashCode()方法得到的

注：^指的是按位异或，h>>>16指的是h算数右移16位。

putVal()代码：

（通过代码中写注释来解释）

    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是hashmap的一个属性，类型是Node<K,V>[]
        //如果table表是null或者大小=0
        //第一次扩容，就到16个空间
        if ((tab = table) == null || (n = tab.length) == 0)
            //这里的resize()方法在下面有讲
            n = (tab = resize()).length;
        //(1)判断应该在table表的哪个索引位置存放，并赋值给p
        //(2)判断p是否为null
        //(2.1)如果p为null，表示没有存放元素，就创建一个Node （key，value）并放在table[i]这个位置
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;//辅助变量
            //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
            //并且满足下面两个条件之一就不能加入：
            //1.准备加入的key和p指向的Node结点的key是同一个对象（字符串在这里就可以判断不相同）
            //2.p指向的Node结点的key的key的equal()方法和准备加入的key比较厚相同（如果是一些引用类对象的话调用equals()方法才能知道）
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //再判断p是不是一颗红黑树
            //如果是一颗红黑树，就调用putTreeVal进行添加
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //如果table对应索引位置，已经是一个链表，就使用for循环比较
            //1.依次和链表的每一个元素比较后，都不相同，就加入到链表末尾
            //2.依次和链表的每一个元素比较过程中，如果有相同情况，就直接break
            //3.
            else {
                for (int binCount = 0; ; ++binCount) {
                    //链表第二个位置开始，因为第一个在上面分析过了
                    //当前Node为null说明当前链表没有跟要加入的元素相同的元素，就加入完跳出
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //TREEIFY_THRESHOLD=8
                        //在把元素添加到链表后，立即判断该链表是否已经达到8个结点，就调用treeifyBin()方法对当前这个链表进行树化(转成红黑树)
                        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=p.next
                    p = e;
                }
            }
            //e != null说明存在相同元素
            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)//size加一跟threshold（默认大小16的0.75倍=12）比较，如果大于12了，就进行resize()扩容
            resize();
        afterNodeInsertion(evict);//为HashMap的子类准备的，对于HashMap就是一个空方法
        return null; //该方法返回空说明put成功了
    }

resize()介绍

1. 扩容方法
2. tab数组的默认大小是16
3. 当存储位置达到12就准备扩容

treeifyBin()介绍

1. 树化方法（链表转化成红黑树）
2. 当链表节点到达8才会进入这个方法
3. 方法先判断table表是否到达64，如果没到达就调用resize()方法扩容

扩容和转成红黑树机制：

1. 第一次添加时，table数组扩容到16，临界值(threshold)是16*加载因子(loadFactor)是0.75=12

2. 如果table数组使用到了临界值12，就会扩容到16*2=32，新的临界值就是32 *0.75=24，以此类推

   1.把第12个数据加入之后紧接着扩容到32

   2.扩容之后原先加入的元素的索引有发生变化

3. 在java8中，如果一条链表的元素个数大于TREEIFY_THRESHOLD(默认是8)，并且table的大小>=MIN_TREEIFY_CAPACITY(默认是64)，就会进行树化（红黑树），否则仍然采用数组扩容机制

   也就是说在同一个链表中插入第九个元素的时候，查看table大小有没有≥64，如果是，就变成红黑树，如果不是，就扩容到两倍，并且把着第九个元素插入到链表最后（此时，当前链表就有9个元素但并没有被树化）。但是因为table大小从16->32->64所以链表最大元素数也就是8➕2（从16变成64的两次扩容）