Java中的HashMap源码浅析_java中hashmap的源码-CSDN博客

本文链接：https://blog.csdn.net/xh13007612005/article/details/89678304

HashMap分析

HashMap是一个存放多组key-value值的map。是由一组Node<K,V>[]数组组成的。它的key不能重复，可以为null。

它默认的负载因子loadFactor是0.75, 默认容量是16，实际容量是16 * 0.75为12，每次扩容都是16的倍数。通过负载因子可以减少哈希碰撞，避免多个key挤在一个位置上，其他数组的位置上没值。

hash()：hash == key.hashCode ^ hash>>>16

在put时：

计算key的hashCode，然后通过数组的length & hash值的方式得到数组的下标
如果数组下标的位置没有存放值，那么就直接放进去。
如果有元素，就判断这个元素的hash值是否等于第一步计算的hash，如果是，就将value覆盖
如果已存在的元素不是要添加的元素，那么就判断这个元素是否是红黑树节点，是的话以红黑树的方式插入
如果不是，表明是链表，就以插入链表的方式插入到尾部。然后检测这条链表的长度是否大于8，大于的话就转换成红黑树。
在插入完成后，将传入的value赋给新的节点

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    
    // map的Node<K,V>[]数组未初始化，进行初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 通过table.length & key.hash得到这个对象应放的下标i
    // 如果这个下标没有值，直接构造个新节点，并且放到数组里
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        // 下标对应的有值
        Node<K,V> e; K k;
        // 判断已存在值的hash是否等于传入的对象的hash，是的话，表示这两个对象的key相同
        // 直接覆盖value
        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 {
            // 如果是链表，构造节点循环插入到尾部。如果链表长度大于8，那么转换为二叉树
            for (int binCount = 0; ; ++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;
            }
        }
        
        // 赋值操作
        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;
}

get()方法：

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 判断map是否为null
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // 查看数组对应下标的first元素是否是要找的
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            // 取到first的next，如果是树节点，就返回树节点
            if (first instanceof TreeNode)
                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;
}

Fail-Fast机制：通过modCount域（修改次数），对HashMap的修改都会使它自增。在迭代HashMap时，迭代之前获取一次这个值，迭代之后获取一次这个值。如果2次的值不相等，表明别的线程在迭代的时候修改了HashMap，这时候就抛出ConcurrentModificationException异常。

HashMap在扩容时，判断每个数组的数的长度大于6，就转换成链表