【Java 基础】HashMap & HashSet

weixin_38491553

已于 2023-08-14 15:38:10 修改

阅读量27

点赞数

分类专栏： JAVA 基础文章标签： java 哈希算法开发语言

于 2023-08-11 15:36:53 首次发布

本文链接：https://blog.csdn.net/weixin_38491553/article/details/132175353

版权

JAVA 基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

HashMap 的底层实现

HashMap的实现就是哈希表

HashMap 通过 key 的 hashcode 经过一个hash()扰动函数处理过后得到 hash 值目的是减少碰撞

//JDK 1.8 HashMap 的 hash 方法
hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); 
        // 拿到key的HashCode 与 HashCode位移运算后的数据做异或运算
}
    
 //JDK1.7 的 HashMap 的 hash 方法源码. 
 hash(int h) {
 	h ^= (h >>> 20) ^ (h >>> 12); 
 	return h ^ (h >>> 7) ^ (h >>>4);
 }

通过 (n - 1) & hash 判断当前元素的位置，如果当前位置存在元素的话，hash 和 key 是否相同，如果相同，直接覆盖，不相同就通过拉链法解决冲突，如果链表元素个数大于等于TREEIFY_THRESHOLD(8)，装换成红黑树，转换之前会先判断table的长度是否大于64，否则先扩容

//JDK 1.8
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;
        if ((p = tab[i = (n - 1) & hash]) == null) // 通过 (n - 1) & hash 判断当前元素的位置
            tab[i] = newNode(hash, key, value, null); //不存在元素直接放进去
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;  // hash值和key相同直接覆盖
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 如果链表元素个数大于等于TREEIFY_THRESHOLD(8)，装换成红黑树
                        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;
    }
// 转换红黑树的方法
final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        // 小于64会先扩容
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        // 超过64才转换红黑树
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

转换红黑树的阙值之所以是8，是因为Java的源码贡献者在进行大量实验发现，hash碰撞发生8次的概率已经降低到了0.00000006，几乎为不可能事件，一旦真的碰撞发生了8次，那么这个时候说明由于元素本身和hash函数的原因，此次操作的hash碰撞的可能性非常大了，后序可能还会继续发生hash碰撞。所以，这个时候，就应该将链表转换为红黑树。最后，红黑树转链表的阈值为6，主要是因为，如果也将该阈值设置于8，那么当hash碰撞在8时，会反生链表和红黑树的不停相互激荡转换，白白浪费资源。

HashMap 的⻓度为什么是 2 的次方

上述提到HashMap中 (n - 1) & hash这个哈希函数计算哈希地址，当 n是2的幂次方的时候 (n - 1) & hash = hash % n, 位运算效率高于取余运算的。
总而言之可以理解为这个用的是除留余数法取哈希值，只有当HashMap 的⻓度为什么是 2 的次方时候可以用效率更高的 &运算去做取余。