HashMap源码阅读之get/put/resize方法

HashMap也算是面试常问知识点了，现在把自己阅读源码学习到的相关知识总结一下

1.get方法

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

可以看到这个方法会调用getNode方法，参数为key的hashcode（int类型）和key对象本身（Object类型），如果结果不为null，返回对应entry的值

再来看getNode方法

final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;   // 创建一个tab数组，数组的每个元素类型为Node<K,V>，看作key-value键值对
        if ((tab = table) != null && (n = tab.length) > 0 &&     //如果这个数组不为null且长度大于0，并且传入的key的hash值在数组中能够找到对应的不为空的元素
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))   //在hashcode相等的情况下，判断key对象是否相等：是否为同一对象（==）/ 不同对象调用equals()进行比较
                return first;
            if ((e = first.next) != null) {           //哈希冲突之后，选择拉链或者红黑树（链的长度超过8变为红黑树）
                if (first instanceof TreeNode)        //红黑树的节点处理（这里跳过，还没分析过红黑树 QAQ）
                    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;
    }

 对于first = tab[(n - 1) & hash]，做一个单独说明：

　　我们知道每次放入元素的时候它的位置是根据key的hashcode确定的，当然有可能key不同，但是hashcode相同，即所谓的哈希冲突，这个的解决方法稍后再提。

　　HashMap数组默认的初始化长度为16，扩容时长度必须是2的幂，有没有小伙伴疑惑为何呢~且听我解释一波。

　　在放数据的时候，最理想的情况是将所有的数据均匀的分布在数组中，所以利用key的hashcode可以做个运算。可能最先想到的是hashcode（key）% tab.length，但其实取模运算的效率并不算高，比较完美的是位运算：

　　hashcode(key) & (tab.length-1)

　　那么为何是与数组长度-1按位相与呢？举个栗子：如果长度为16，那么length-1=15，15的二进制位1111，即任何一个hashcode与之按位与，只要输入的hashcode是均匀分布的，那么hash算法的结果就是均匀的。

　　此处感谢程序员小灰的一篇文章http://mp.weixin.qq.com/s/HzRH9ZJYmidzW5jrMvEi4w（我没大讲清楚的话戳这篇文章）

2.put方法

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

同样的，普通方法也去调用了另一个方法，注意传入的参数，其中有两个参数感觉平时没有见过，可以看一下源码中给出的注释

@param onlyIfAbsent if true, don't change existing value
@param evict if false, the table is in creation mode.

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;    //如果数组的初始长度为0，初始化它的长度
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);    //如果hash到的位置没有值，则直接将该节点放入这个位置
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))   //hash到的位置有值，且它们的key相等
                e = p;    //将该节点赋给节点e(新创建的，稍后会做处理)
            else if (p instanceof TreeNode)    //如果不相等，且p节点为树节点，则以红黑树或者链表的形式插入这个新的节点
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);   //红黑树不做分析（因为我不会...有机会补充
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {    //如果p节点的next为空，p.next为新插入的节点，break
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st   //如果拉链长度超过7(阈值static final int TREEIFY_THRESHOLD=8),扩展为红黑树，此为JDK1.8的新特性
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&   //如果p节点的next不为空，判断是否和要插入的节点的key相等，如果相等话break
                        ((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;   //将新值设置为e的值
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;   //记录修改次数，和线程安全有关系
        if (++size > threshold)
            resize();   //扩容
        afterNodeInsertion(evict);
        return null;
    }

 modecount讲解：

fail-fast策略——hashmap非线程安全，在使用迭代器遍历hashmap的时候，如果有其他的线程修改了hashmap(set/put等操作)，将抛出异常

hashmap的初始化过程会将当前modecount的值赋给迭代器（expectedModeCount），然后迭代的过程中会判断二者是否相等，如果不相等，说明有线程修改了hashmap

此外，modecount声明为volatile，因此任何一个线程的修改对于其他线程来说都是可见的

-------

以上有一个疑问，我记得插入新的节点的时候，如果拉链，是将新节点作为链的头部，为何这里看起来不是？

3.resize方法

 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;   //如果table为null,原始的capacity为1，否则为它的长度
        int oldThr = threshold;  //阈值（当前数组长度*加载因子，一般为0.75）
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {  //如果原始数组的长度已经大于最大容量（2^30），则将阈值设为Tnteger.MAX_VALUE，这样就不会再扩容了
                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   //如果原始的数组等于0且原始的阈值大于0.则将其赋给新的数组长度
            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) {   //遍历这个hash表进行重新hash
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {   //获取第j个不为null的元素，将其置为null
                    oldTab[j] = null;
                    if (e.next == null)   //如果第j个节点的next为null,直接寻找这个节点的新位置  e.hash & (newCap-1)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)   //红黑树的节点的处理（省略，我真的不会QAQ）
                        ((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;
    }

代码部分缺省的介绍可以参考这个博主的，我认为它的链表复制部分的讲解非常清晰~

https://blog.csdn.net/u013494765/article/details/77837338