HashMap的内部实现机制的奥妙

最新推荐文章于 2021-03-23 18:52:01 发布

jiankangzhu

最新推荐文章于 2021-03-23 18:52:01 发布

阅读量123

点赞数

分类专栏： java学习

本文链接：https://blog.csdn.net/jiankangzhu/article/details/104686860

版权

java学习专栏收录该内容

22 篇文章 0 订阅

订阅专栏

本文探讨了HashMap的内部实现，其由数组和链表/树形结构组成，哈希值决定键值对在数组中的位置。当哈希碰撞过多导致链表过长时，会转为树形结构。HashMap的构造函数、初始容量、负载因子及其关系被详细分析，指出容量*负载因子>元素数量的公式。默认容量为16，负载因子为0.75，当链表长度达到7时，会转为红黑树以提高查找效率。

摘要由CSDN通过智能技术生成

俗话说"工欲善其事，必先利其器"，只有明白它的内部实现机制，我们才能更好的使用HashMap为我们服务。接下来让我们一步一步的解开它神秘的面纱。

1 首先我们来看看它的内部结构

它可以看作是数组(Node<>[] table)和链表结合而成的复合结构，数组被分为一个一个桶(bucket),通过哈希值决定了键值对在数组中的寻址，哈希值相同的键值对会形成链表，(这就是我们常说的Hash碰撞)，如果哈希碰撞概率过大，也就是说链表大小超过阈值(TREEIFY_THRESHOLD, 8),链表就会变成树形结构，这也就说发生哈希碰撞的越多，我们获取对应的值就会越慢，毕竟系统维护链表和树形结构也需要时间的。

2 接下来分析一下HashMap的源码

首先HashMap有4个构造函数

public HashMap(int initialCapacity, float loadFactor);
public HashMap(int initialCapacity);
public HashMap();
public HashMap(Map<? extends K, ? extends V> m);

initialCapacity可以翻译为初始容量，loadFactor可以翻译为负载因子。那么我们为什么需要在乎容量和负载因子呢？这是因为容量和负载因子决定了可用桶的数量，空桶太多会浪费空间，如果使用的太满又会影响操作的性能。极端情况下，它就退化为一个链表，完全不能提供所谓的常数时间存的性能。既然容量和负载因子这么重要，那么我们该如何选择呢？有一个公式，容量 * 负载因子 > 元素数量，预先设置的容量需要满足，大于预估元素数量/负载因子，同时它是2的幂数。

对于负载因子，如果没有什么特别需求，不要轻易更改负载因子，因为JDK的默认负载因子是非常符合通用场景的需求的，如果确实需要调整，建议不要超过0.75，因为会显著增加冲突，降低HashMap性能。

默认的容量是16,默认的负载因子是0.75

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final float DEFAULT_LOAD_FACTOR = 0.75f;

然后研究一下put方法

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

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //如果数组空间为空，resize()函数返回一个Node<K,V>类型的数组
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //如果在数组tab空间找到对应的索引位置，就创建一个Node<K,V>元素放入数组中
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {         //如果找到的索引位置已经有值的话，分3种情况
            Node<K,V> e; K k;
            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) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //如果链表元素超过了6个，也就是大于等于7，把链表结构转换为树形结构
                        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;
    }

为什么链表元素大于等于7的时候，链表存储结构要转换为属性结构呢？这个可能跟性能，空间有关系吧，我在其它地方看到一个说法，红黑树的平均查找长度是log2(n),链表的平均查找长度是n/2,当n=6时，log2(6)=2.6, 6/2=3,但是还要考虑到链表转换为树形结构的开销，JAVA源码开发者找到了数字7，即链表长度大于等于7的时候，链表结构转化为树形结构，这样可以提高查找效率。