深入理解 Java HashMap

最新推荐文章于 2024-06-06 09:59:08 发布

vm04580

最新推荐文章于 2024-06-06 09:59:08 发布

阅读量127

点赞数 1

分类专栏： Java学习文章标签： HashMap

本文链接：https://blog.csdn.net/ly52014/article/details/99704805

版权

Java学习专栏收录该内容

52 篇文章 0 订阅

订阅专栏

HashMap源码解读（内部哈希算法、负载因子、树化、扩容）

树化： 当数组下标对应的链表长度 >= 8(添加完新结点之后的链表长度），并且此时哈希表的长度 >= 64，将链表树化，否则只是进行了简单的扩容处理
树化原因： 当链表长度过长时，哈希表的CURD的时间复杂度会退化为O(n)

static final int TREEIFY_THRESHOLD = 8;//默认树化阈值
static final int UNTREEIFY_THRESHOLD = 6;//默认解除树化阈值

负载因子：决定了哈希表在达到容量的百分比大小，进行扩容阈值

final float loadFactor;// 默认值 0.75

若负载因子 > 0.75，增加了哈希表的利用率，但是哈希冲突的概率明显增加
若负载因袭 < 0.75，降低了哈希冲突的概率，同时也降低了空间利用率

扩容：resize()，每次哈希表扩容时，扩容为原来的2倍

if (oldCap >= MAXIMUM_CAPACITY) {
    threshold = Integer.MAX_VALUE;
    return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
         oldCap >= DEFAULT_INITIAL_CAPACITY)
    newThr = oldThr << 1; // double threshold

内部哈希算法：

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    //(h = key.hashCode()) ^ (h >>> 16) 将高低16位都参与异或运算，减少哈希冲突
}

为何HashMap中不直接采用key值的hashCode()计算哈希值？
因为Object提供的hashCode得到的是一个32位整数，直接将其作为数组下标会浪费大量空间
真正的数组下标：(n-1) & hash();保证得到的下标一定在数组长度范围内
n=table.length;——默认值16

（1）为什么hash()得到的值任然不能直接作为数组下标？

即使对hash(）的值保留最高16位，得到的值还有可能很大

（2）为什么HashMap中哈希表的长度始终为 2^n?

2^n - 1的二进制中所有的位数都为1，可以保证哈希表中所有的下标都有几乎被访问到

HashMap添加元素：
采用懒加载策略，第一次添加元素时进行初始化

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; Node<K,V> p; int n, i;
    //哈希表未被初始化时，第一次调用put方法，进行初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        //初始化
        n = (tab = resize()).length;
        
        //key值计算后的数组下标没有存储元素，将元素直接添加到该下标处
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        //此时，哈希表已经初始化并且计算后的key值下标处存在元素
        Node<K,V> e; K k;
        //需要插入的元素key值与数组元素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 {
            //链表形式的插入
            for (int binCount = 0; ; ++binCount) {
                //链表中没有元素的key值与当前相等，尾插
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //插入元素之后判断此时是否需要树化
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //当前元素key值与链表中某一节点key值相等，更新值
                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;
    //判断当前哈希表的长度是否大于容量，是否需要扩容
    //threshold = table.length * loadFactor
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}