HashMap.put()方法源码解析

HashMap.put()流程:
首先说明,HashMap通过数组+链表/红黑树管理
1.计算需要插入的元素的hash值。
2.第一次插入的话,hash数组默认是空,调用resize()方法,开辟一个长度为默认值的entry数组table,entry指的是包含了哈希值,key,value和后继地址的类,一个entry对象对应一个元素对。开始我不理解我什么要记录每个元素对的key的hash值,阅读源码得知,可能会发生哈希冲突,即两个哈希值不同的元素放到一个链表/红黑树里面。另外扩容的时候需要根据哈希值重新分配table位置。很多博客作图表现出了table中只存储头节点,不存储具体数据。这是错误的。jdk1.8中,源码明显说明table是存储元素数据的。
3.待插入元素的哈希值和(数组长度-1)&运算,显然结果小于等于(数组长度-1),即确定了插入数组的位置。
4.找到位置后,进行插入。这个位置上是一个链表/红黑树。红黑树太复杂了,我现在只考虑链表情况。从表头遍历到表尾,如果发现某个节点和待插入节点的key的哈希值相等,并且equals之下相等,那么用新value覆盖旧的value,找不到的话插到末尾。如果这个时候链表长度大于阈值,将其变为红黑树。
5**.看hashmap中的总分节点个数是否大于阈值**,是的话调用resize()方法扩容。这个非常关键,很多博客写的是错的。
看源码

插入部分

重要的成员变量

transient Node<K,V>[] table;   //存储链表/红黑树的头
transient int size;    //hashmap中的元素总个数

记录键值对的数据结构

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
        }

计算哈希值的方法

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

put方法底层是putVal()方法

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

重点分析putVal方法

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab;  //临时表,赋值为table
        Node<K,V> p;    //临时节点  
        int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)  //table为空,显然是第一次插入
            n = (tab = resize()).length;     //resize()方法开辟空间,首地址返回给tab
        if ((p = tab[i = (n - 1) & hash]) == null)      //根据哈希值计算插入元素在table中的位置,如果是空,说明这个位置没有被占用过,直接放入
            tab[i] = newNode(hash, key, value, null);   //在table中的这个位置放入元素,注意,这里说明table存储的不是头指针,是数据
        else {
            Node<K,V> e; K k;     //这个e表示的是待覆盖的节点
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))    //说明table某个位置上的元素和待插入元素的key的哈希值相同,而且equals()方法也成立,应该用新value覆盖旧的value
                e = p;      //记录这个位置,待覆盖
            else if (p instanceof TreeNode)     //判断是不是红黑树,红黑树太复杂了,看不懂
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {          //这个是链表情况
                for (int binCount = 0; ; ++binCount) {     //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;       //说明链表某个位置上的元素和待插入元素的key的哈希值相同,而且equals()方法也成立,应该用新value覆盖旧的value
                }
            }
            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;
    }

可以看出,两次扩容操作调用没有区别,但是一次是开辟空间,另一次是空间乘2,怎么回事呢?

resize()源码分析

 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;     //扩容之前的table
        int oldCap = (oldTab == null) ? 0 : oldTab.length;    //如果没有初始化,原有的表容量是0
        int oldThr = threshold;        //原有的扩容阈值,初始化前是0
        int newCap, newThr = 0;     //新容量和新阈值
        if (oldCap > 0) {           //已经初始化了的情况
            if (oldCap >= MAXIMUM_CAPACITY) {    //超过了int最大值,自生自灭吧
                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 {               // 这个是初始化情况
            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;          //threshold 是记录容量的全局变量
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];   //开辟entry数组,大小为新容量
        table = newTab;      //给全局变量table赋值
        if (oldTab != null) {      //这个是判断是否初始化了
            for (int j = 0; j < oldCap; ++j) {     //遍历原table
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {       
                    oldTab[j] = null;
                    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
                        Node<K,V> loHead = null, loTail = null;    //往下我看不懂了,有大神说是nb的位运算,但是整个过程可以看出来尾插法
                        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;
    }

jdk1.8以前的多线程不安全:

简单地说,就是由于头插法引起的。
比如table中某位置有元素entry1->entry2.扩容后需要放入新的位置。线程1记录的是entry1->entry2,但是线程2采用头插法,会将原来的链表逆序。这可能产生循环链表。而操作默认是无环的,就会出现死循环。

你可能感兴趣的:(HashMap.put()方法源码解析)