Java8的集合:HashMap的实现原理

    技术2022-07-13  63

    概述

    哈希表是基于 Map 接口的实现的,它允许 null 值和null 键,它不是线程同步的,同时也不保证有序。Map的这种实现方式为 get(取)和 put(存)带来了比较好的性能。但是如果涉及到大量的遍历操作的话,就尽量不要把 capacity 设置得太高(或 load factor 设置得太低),否则会严重降低遍历的效率。影响 HashMap 性能的两个重要参数:initial capacity(初始化容量)和load factor(负载因子)。简单来说,容量就是哈希表桶的个数,负载因子就是键值对个数与哈希表长度的一个比值,当比值超过负载因子之后,HashMap 就会进行 rehash操作来进行扩容。HashMap 的大致结构如下图所示,其中哈希表是一个数组,我们经常把数组中的每一个节点称为一个桶,哈希表中的每个节点都用来存储一个键值对。在插入元素时, 如果发生冲突(即多个键值对映射到同一个桶上)的话,就会通过链表的形式来解决冲突。因为一个桶上可能存在多个键值对,所以在查找的时候,会先通过 key 的哈希值先定位到桶,再遍历桶上的所有键值对,找出 key 相等的键值对,从而来获取 value。

    属性

    /** * 默认的初始容量为16 */ static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 /** * 最大的容量上限为2^30 */ static final int MAXIMUM_CAPACITY = 1 << 30; /** * 默认的加载因子为0.75 */ static final float DEFAULT_LOAD_FACTOR = 0.75f; /** * 桶的树化阈值:即 链表转成红黑树的阈值, * 在存储数据时,当链表长度 > 该值时,则将链表转换成红黑树 */ static final int TREEIFY_THRESHOLD = 8; /** *桶的链表还原阈值:即 红黑树转为链表的阈值,当在扩容(resize())时(此时HashMap的数据存储位置会 *重新计算),在重新计算存储位置后,当原有的红黑树内数量 < 6时,则将 红黑树转换成链表 * */ static final int UNTREEIFY_THRESHOLD = 6; /** * 最小树形化容量阈值:即 当哈希表中的容量 > 该值时,才允许树形化链表 (即 将链表 转换成红黑树) * 否则,若桶内元素太多时,则直接扩容,而不是树形化 * 为了避免进行扩容、树形化选择的冲突,这个值不能小于 4 * TREEIFY_THRESHOLD */ static final int MIN_TREEIFY_CAPACITY = 64; /** * 哈希表 */ transient Node<K, V>[] table; /** * 哈希表中键值对的个数 */ transient int size; /** * 哈希表被修改的次数 */ transient int modCount; /** * 它是通过 capacity*load factor 计算出来的,当 size 到达这个值时, 就会进行扩容操作 */ int threshold; /** * 加载因子 */ final float loadFactor;

    下面是Node类的定义,它是HashMap中的一个静态内部类,哈希表中的每一个节点都是Node类型。我们可以看到,Node类中有4个属性,其中除了key和value之外,还有hash和next两个属性。hash是用来存储key的哈希值的,next是在构建链表时用来指向后继节点的。

    static class Node<K, V> implements Map.Entry<K, V> { final int hash; final K key; V value; Node<K, V> next; Node(int hash, K key, V value, Node<K, V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?, ?> e = (Map.Entry<?, ?>) o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } }

    方法

    get方法

    实现步骤大致如下: 1、通过 hash 值获取该 key 映射到的桶。 2、桶上的 key 就是要查找的 key,则直接命中。 3、桶上的 key 不是要查找的 key,则查看后续节点: (1)如果后续节点是树节点,通过调用树的方法查找该 key。 (2)如果后续节点是链式节点,则通过循环遍历链查找该 key。

    /** * get方法主要调用的是getNode方法 */ public V get(Object key) { Node<K, V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K, V> getNode(int hash, Object key) { Node<K, V>[] tab, first, e; int n; K k; // 如果哈希表不为空&&key对应的桶上不为空 if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { // 是否直接命中 if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k)))) return first; // 判断是否有后续节点 if ((e = first.next) != null) { // 如果当前的桶是采用红黑树处理冲突,则调用红黑树的get方法去获取节点 if (first instanceof TreeNode) return ((TreeNode<K, V>) first).getTreeNode(hash, key); // 不是红黑树的话,采用传统的链式结构,通过循环的方法判断链中是否存在该key do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }

    put方法

    put 方法比较复杂,实现步骤大致如下:

    先通过 hash 值计算出 key 映射到哪个桶。如果桶上没有碰撞冲突,则直接插入。如果出现碰撞冲突了,则需要处理冲突: 如果该桶使用红黑树处理冲突,则调用红黑树的方法插入否则采用传统的链式方法插入。如果链的长度到达临界值,则把链转变为 红黑树 如果桶中存在重复的键,则为该键替换新值如果 size 大于阈值,则进行扩容 /** *put 方法的具体实现也是在 putVal 方法中,所以我们重点看下面的 putVal 方法 */ 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; // 如果哈希表为空,则创建一个哈希表 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //如果当前桶没有碰撞冲突,则直接把键值对插入,结束 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K, V> e; K k; //如果桶上节点的key与当前key重复,则就是要找的节点 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; //如果是采用红黑树的方式处理冲突,则通过红黑树的putTreeVal方法去插入这个键值对 else if (p instanceof TreeNode) e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value); else {//否则就是传统的链式结构 //采用循环遍历的方式,判断链中是否有重复的key for (int binCount = 0; ; ++binCount) { //到了链尾还没有找到重复的key,则说明HashMap没有包含该键 if ((e = p.next) == null) { // 创建一个新节点插入到尾部 p.next = newNode(hash, key, value, null); // 如果链的长度大于TREEIFY_THRESHOLD这个临界值,则把链变成红黑树 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } // 找到了重复的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; // 判断是否需要进行扩容 if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }

    remove方法

    /** * remove 方法的具体实现在 removeNode 方法中,所以我们重点看下面的 removeNode 方法 * @param key * @return */ public V remove(Object key) { Node<K, V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } final Node<K, V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K, V>[] tab, p; int n, index; // 如果当前key映射到的桶不为空 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; //如果桶上的节点就是要找的key,则直接命中 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 = e; } while ((e = e.next) != null); } } //比对找到的key的value跟要删除的是否匹配 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; }

    hash方法

    在get 方法和 put 方法中都需要先计算 key 映射到哪个桶上,然后才进行之后的操作,计算的主要代码如下:

    (n - 1) & hash

    上面代码中的 n 指的是哈希表的大小,hash 指的是 key 的哈希值,hash 是通过下面这个方法计算出来的,采用了二次哈希的方式,其中 key 的 hashCode 方法是一个native 方法:

    static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }

    这个 hash 方法先通过 key 的 hashCode 方法获取一个哈希值,再拿这个哈希值与它的高 16 位的哈希值做一个异或操作来得到最后的哈希值,计算过程可以参考下图。为啥要这样做呢?

    注释中是这样解释的:如果当 n 很小,假设为 64 的话,那么 n-1即为 63(0x111111),这样的值跟 hashCode()直接做与操作,实际上只使用了哈希值的后 6 位。如果当哈希值的高位变化很大,低位变化很小,这样就很容易造成冲突了,所以这里把高低位都利用起来,从而解决了这个问题

    正是因为与的这个操作,决定了 HashMap 的大小只能是 2 的幂次方,想一想,如果不是 2 的幂次方,会发生什么事情?即使你在创建 HashMap 的时候指定了初始大小,HashMap 在构建的时候也会调用下面这个方法来调整大小:

    static final int tableSizeFor(int cap) { int n = cap - 1; n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }

    这个方法的作用看起来可能不是很直观,它的实际作用就是把 cap 变成第一个大于等于 2 的幂次方的数。例如,16 还是 16,13 就会调整为 16,17 就会调整为 32

    关于HashMap初始容量的相关疑问

    HashMap是根据key的hash值决策key放入到哪个桶(bucket)中,通过 tab=[(n - 1) & hash] 公式计算得出。其中tab是一个哈希表

    为什么要保证 capacity 是2的次幂呢?

    在get方法实现中,实际上是匹配链表中的 Node[] tab 中的数据。(n - 1) & hash实际上是计算出 key 在 tab 中索引位置,当key的hash没有冲突时,key在HashMap存储的位置就是匹配的node中的第一个节点。如果hash有冲突,就会在node里面节点中查询,直至匹配到相等的key。因为 n 永远是2的次幂,所以 n-1 通过二进制表示,永远都是尾端以连续1的形式表示(00001111,00000011),当(n - 1) 和 hash 做与运算时,会保留hash中 后 x 位的 1,例如 00001111 & 10000011 = 00000011这样做有2个好处 &运算速度快,至少比%取模运算块能保证 索引值 肯定在 capacity 中,不会超出数组长度(n - 1) & hash,当n为2次幂时,会满足一个公式:(n - 1) & hash = hash % n

    为啥非得是2的幂次方 ,2的倍数不行么,奇数不行么?

    结合源码加网上相关的资料,解释如下

    奇数不行的解释很能被接受,在计算hash的时候,确定落在数组的位置的时候,计算方法是(n - 1) & hash ,奇数n-1为偶数,偶数2进制的结尾都是0,经过&运算末尾都是0,会增加hash冲突。为啥要是2的幂,不能是2的倍数么,比如6,10?hashmap 结构是数组,每个数组里面的结构是node(链表或红黑树),正常情况下,如果你想放数据到不同的位置,肯定会想到取余数确定放在那个数据里, 计算公式: hash % n,这个是十进制计算。在计算机中, (n - 1) & hash,当n为2次幂时,会满足一个公式:(n - 1) & hash = hash % n,计算更加高效。只有是2的幂数的数字经过n-1之后,二进制肯定是 …11111111 这样的格式,这种格式计算的位置的时候,完全是由产生的hash值类决定,而不受n-1 影响。你可能会想,受影响不是更好么,又计算了一下 ,hash冲突可能更低了,这里要考虑到扩容了,2的幂次方*2,在二进制中比如4和8,代表2的2次方和3次方,他们的2进制结构相 似,比如4和8 00000100 0000 1000 只是高位向前移了一位,这样扩容的时候,只需要判断高位hash,移动到之前位置的倍数就可以了,免去了重新计算位置的运算。

    为什么要通过 (n - 1) & hash 决定桶的索引呢?

    key具体应该在哪个桶中,肯定要和key挂钩的,HashMap顾名思义就是通过hash算法高效的把存储的数据查询出来,所以HashMap的所有get 和 set 的操作都和hash相关。既然是通过hash的方式,那么不可避免的会出现hash冲突的场景。hash冲突就是指 2个key 通过hash算法得出的哈希值是相等的。hash冲突是不可避免的,所以如何尽量避免hash冲突,或者在hash冲突时如何高效定位到数据的真实存储位置就是HashMap中最核心的部分首先要提的一点是 HashMap 中 capacity 可以在构造函数中指定,如果不指定默认是2 的 (n = 4) 次方,即16HashMap中的hash也做了比较特别的处理,(h = key.hashCode()) ^ (h >>> 16) 先获得key的hashCode的值 h,然后 h 和 h右移16位 做异或运算实质上是把一个数的低16位与他的高16位做异或运算,因为在前面 (n - 1) & hash 的计算中,hash变量只有末x位会参与到运算。使高16位也参与到hash的运算能减少冲突。 例如1000000的二进制是 00000000 00001111 01000010 01000000右移16位: 00000000 00000000 00000000 00001111异或 00000000 00001111 01000010 01001111

    capacity 永远都是 2 次幂,那么如果我们指定 initialCapacity 不为 2次幂时呢,是不是就破坏了这个规则?

    答案是不会的,HashMap的tableSizeFor方法做了处理,能保证n永远都是2次幂。 /** * Returns a power of two size for the given target capacity. */ static final int tableSizeFor(int cap) { //cap-1后,n的二进制最右一位肯定和cap的最右一位不同,即一个为0,一个为1,例如cap=17(00010001),n=cap-1=16(00010000) int n = cap - 1; //n = (00010000 | 00001000) = 00011000 n |= n >>> 1; //n = (00011000 | 00000110) = 00011110 n |= n >>> 2; //n = (00011110 | 00000001) = 00011111 n |= n >>> 4; //n = (00011111 | 00000000) = 00011111 n |= n >>> 8; //n = (00011111 | 00000000) = 00011111 n |= n >>> 16; //n = 00011111 = 31 //n = 31 + 1 = 32, 即最终的cap = 32 = 2 的 (n=5)次方 return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }

    小结

    在这里有一个需要注意的地方,有些文章指出当哈希表的桶占用超过阈值时就进行扩容,这是不对的;实际上是当哈希表中的键值对个数超过阈值时,才进行扩容的。按照原来的拉链法来解决冲突,如果一个桶上的冲突很严重的话,是会导致哈希表的效率降低至 O(n),而通过红黑树的方式,可以把效率改进至 O(logn)。相比链式结构的节点,树型结构的节点会占用比较多的空间,所以这是一种以空间换时间的改进方式
    Processed: 0.013, SQL: 9