HashMap 核心源码分析 （jdk8）

写在前面

如果对 HashMap 的基本工作原理不清楚，继续阅读后续内容的效果不是很好，建议先学习前置知识HashMap 基本工作原理 ： https://my.oschina.net/j4love/blog/1797058

java.util.HashMap#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 为 null 说明是首次调用 put 方法 , 进行 resize 操作真正为 table 分配存储空间

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

        // i = (n - 1) & hash 计算出的值判断 table[i] 是否为 null , 
        // 如果为 null 就为 key ， value 创建一个新的 Node 节点 ,
        // 不需要进行碰撞检测直接存储在 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 是否和 bucket 中存储的头节点相同
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;

            // 检测 bucket 中当前存放的节点类型是不是红黑树结构 ,
            // 是红黑树结构 , 存储为一个红黑树节点

            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {

                // 这个 bucket 中存放的节点是链表结构 , 
                // 循环直到链表的末尾或者是找到相同的 key 

                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);

                        // 存储新节点的时候 ， 检测链表长度是否超过 TREEIFY_THRESHOLD - 1 ,
                        // 超过的话将链表转换为红黑树结构 ,提高性能

                        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;
                }
            }

            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }

        // 并发修改计数器 ,有并发修改就抛异常 ConcurrentModificationException
        ++modCount;

        // 存储了一个新节点 ， 检测 size 是否超过 threshold 
        // 如果超过了要进行 resize 操作
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

java.util.HashMap#getNode

    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;

        // 检测 table 中是否已经存储了节点 ，
        // 检测key所在的 bucket 是否存储了节点 ，
        // 以上两点都不满足说明 key 不存在

        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {

            // 对 bucket 中存储节点的头结点进行碰撞检测 ,
            // 如果运气好的话只需要进行这一次碰撞检测

            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;

            // 检测 bucket 存储的节点是否是单个节点

            if ((e = first.next) != null) {

                // 检测节点数据结构是否是红黑树

                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {

                    // 节点是链表数据结构，循环直到链表末尾或者是发现 key 一致的节点
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

java.util.HashMap#removeNode

final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> node = null, e; K k; V v;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                    
                        // p 是 node 的前一个节点
                        p = e;
                    } while ((e = e.next) != null);
                }
            }

            // 以上代码是 getNode(hash , key) , 个人觉得这个函数中的代码冗余了

            // 获取到 key 对应的节点 ， 判断是否要进行值匹配

            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {

                // 进行删除操作 , 红黑树的删除是比较复杂的 , 链表的删除十分简单
                                     
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                else if (node == p)
                    tab[index] = node.next;
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

java.util.HashMap#clear

    public void clear() {
        Node<K,V>[] tab;
        modCount++;
        if ((tab = table) != null && size > 0) {
            size = 0;

            // 很简单把数组中每个位置设置为 null
            for (int i = 0; i < tab.length; ++i)
                tab[i] = null;
        }
    }