HashMap学习（二）（基于JDK 1.8)

最新推荐文章于 2024-05-03 08:43:42 发布

晓之木初

最新推荐文章于 2024-05-03 08:43:42 发布

阅读量211

点赞数 1

分类专栏： java相关 # Java基础文章标签： java 数据结构

本文链接：https://blog.csdn.net/u014454538/article/details/120445231

版权

java相关同时被 2 个专栏收录

93 篇文章 9 订阅

订阅专栏

Java基础

20 篇文章 16 订阅

订阅专栏

温馨提示：

在本文中，entry、节点、映射的含义，几乎是等同的，不要因为一会说entry、一会说节点就蒙圈

3. 查找方法

3.1 get方法

回忆之前学习TreeMap时，get()方法的实现：通过getEntry()获取到key对应的entry，然后再返回entry中的value

HashMap中的 get() 方法也是照葫芦画瓢：

返回的值为null，可能是map中不存在key的映射，也可能是映射的值本身就是null

要想判断map中是否存在key的映射，还是需要调用containsKey()方法

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

核心方法：getNode()

猜测，getNode()方法需要分情况查找节点（即entry）：① 桶中的节点以链表的形式组织；② 桶中的节点以红黑树的形式组织

不同的结构，将使用不同的遍历逻辑

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 计算桶下标，对应桶中存在节点
    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;
        // 根据头节点下面连接的是红黑树 or 链表，分情况遍历
        if ((e = first.next) != null) {
            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;
}

3.2 containsKey方法

学习了get()方法，接着要学习的肯定是containsKey()方法
思路与TreeMap一致：先获取节点，然后判断节点是否存在，从而判断map中是否包含key

或者说，判断map中是否存在key的映射

public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}

3.3 containsValue方法

TreeMap中也有containsValue() 方法，只是自己的使用的不多，被忽略了而已 😂

HashMap的 containsValue() 方法代码如下：

public boolean containsValue(Object value) {
    Node<K,V>[] tab; V v;
    if ((tab = table) != null && size > 0) {
        // 以链表的形式遍历每个桶
        for (int i = 0; i < tab.length; ++i) {
            for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                if ((v = e.value) == value ||
                    (value != null && value.equals(v)))
                    return true;
            }
        }
    }
    return false;
}

疑问： 桶中可能是红黑树，怎么还以链表的形式遍历呢？

HashMap学习（一）中，提到HashMap的TreeNode实际继承了自身的Node，通过next和prev指针，在树化后仍然保留了原链表的节点顺序
因此，这也是为何以链表的形式遍历桶中的节点，而没有考虑红黑树或链表两种情况的原因

3.4 getOrDefault方法

爱刷题的同学就会发现，经常使用HashMap的getOrDefault()方法，在key不存在时返回一个默认值的情况。
尤其是，使用HashMap实现计数的时候
getOrDefault() 方法是Map接口，在JDK1.8时新增的方法

getOrDefault() 方法的代码如下：
（1）不存在key的映射，则返回默认值defaultValue；
（2）否则，返回映射的value

public V getOrDefault(Object key, V defaultValue) {
     Node<K,V> e;
     return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
 }

4. put方法

4.1 put()方法概述

使用过HashMap的同学，应该都知道通过put()方法可以添加key-value
- 存在key的映射，则更新原始的value；
- 不存在key的映射，则新增entry，存储key-value
- 冷门： put()方法是有返回值的，返回值为oldValue或null
put()方法的代码如下，十分简单，重头戏在putVal()方法
- 粗略一看呢，putVal() 方法的入参包括:key的哈希值、key、value以及两个未知的boolean入参
- putVal() 方法存在返回值，返回值就是oldValue或null
```
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
```

4.2 putVal()方法

putVal()方法的代码如下

onlyIfAbsent参数为true，表示存在key的映射时，不更新oldValue
evict参数为false，表示哈希表处于创建状态（creation mode）
哈希表为空（第一次插入entry），通过扩容实现初始化
哈希表不为空，对应的桶为空，直接插入entry
哈希表不为空，对应的桶也不为空，向桶中更新或插入entry
若存在key的映射，需要更新并返回oldValue；否则，modCount++ 、size++

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;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k)))) // 首节点匹配上，直接记录首节点
            e = p;
        else if (p instanceof TreeNode) // 桶中为红黑树，实现向红黑树中新增节点
            // 若不存在key的映射，返回null
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else { // 桶中未链表，进行链表的遍历与插入
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) { // e指向链表末尾，直接插入节点
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st，binCount >=7，实际是链表长度 > 8，此时将链表转为红黑树
                        treeifyBin(tab, hash);
                    break;
                }
                // 存在key映射，直接退出
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;  // 更新p，指向下一个节点
            }
        }
        if (e != null) { // 存在key的映射,更新并返回oldValue
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null) // onlyIfAbsent为false或oldValue为null，则更新oldValue
                e.value = value;
            afterNodeAccess(e);  // 空实现，在LinkedHashMap中需要实现
            return oldValue; // 返回oldValue
        }
    }
    // 结构发生改变
    ++modCount;
    if (++size > threshold) // entry数大于threshold，需要扩容
        resize();
    afterNodeInsertion(evict); // 空实现
    return null;  // 不存在key的映射，返回null
}

链表转红黑树的条件：链表长度 > 8；链表节点的插入，JDK 1.8采用尾插法

这里的判断实际上让人很迷，看着是binCount >= 7，按照数组中index的对应关系，也就是长度 >= 8。
然而，它是先插入节点后再做的判断，导致链表的长度+1，最终是长度 >= 9，即长度 > 8
注释-1 for 1st，是有深意的，表明第一个节点的 index 为 -1，并非0
附上一个辛辛苦苦画的推导图：假设待插入节点为9，基于链表的插入过程如下：

4.3 treeifyBin()方法

treeifyBin()方法的方法说明如下，大意是：将链表转为红黑树，若哈希表比较小，会扩容而非树化

Replaces all linked nodes in bin at index for given hash unless table is too small, in which case resizes instead.
一下就蒙圈了：链表长度大于8，不就应该将链表转为红黑树了吗？怎么还需要考虑哈希表的大小呢？

还是先来看看代码：

从代码来看，当哈希表为空或长度小于MIN_TREEIFY_CAPACITY（64）时，直接进行扩容操作；
当哈希表容量 >= 64时，会将对应桶中的链表转为红黑树
链表转红黑树：（1）链表节点转树节点，通过prev和next保留链表的节点顺序；（2）使用treeify()方法将树节点组织为红黑树

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    // 哈希表为空，或小于最小树化容量，则进行扩容操作
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) { // 计算index，定位到对应的桶
        TreeNode<K,V> hd = null, tl = null;
        // 将链表节点转为树节点，通过prev和next保留原链表的节点顺序
        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，不一定会转为红黑树，可能会因为扩容被shorten

为什么要超过最小树化容量，才将链表转为红黑树？

链表长度大于8的原因：
- 哈希值散列不均，具有相同哈希值的key很多，从而计算出的桶下标一致，导致链表长度大于8
- 哈希值散列均匀，但哈希表的容量较小，具有不同哈希值的key将对应相同的桶下标，导致链表长度大于8
针对原因二，通过扩容哈希表就可以解决
同时，依然能提供 $O (1)$ 的时间复杂度，而非树化后的 $O(log_2N)$ 的时间复杂度

参考链接：

4.4 扩容方法 —— resize()

resize() 方法的注释如下
- 初始化哈希表，或将哈希表的容量翻倍
- 如果哈希表为空，initialCapacity存储在threshold中，对应的构造方法为public HashMap(int initialCapacity, float loadFactor)或public HashMap(int initialCapacity)
- 容量翻倍：保证哈希表的容量为2的幂；
- 扩容后，桶中的节点（链表节点或红黑树节点）要么保持原位不动，要么移动至新表中offset为2的幂的位置（后续代码中有所体现）
Initializes or doubles table size. If null, allocates in accord with initial capacity target held in field threshold. Otherwise, because we are using power-of-two expansion, the elements from each bin must either stay at same index, or move with a power of two offset in the new table.

resize() 方法的代码如下:

先计算扩容后的哈希表容量和threshold：
（1）哈希表不为空，要么将哈希表的容量和threshold都扩容两倍，要么不再扩容（threshold设为Integer.MAX_VALUE，直接返回oldTable）
（2）哈希表为空，oldThr（即当前的 threshold ）大于0，使用oldThr更新newCap；对应构造函数：public HashMap(int initialCapacity, float loadFactor)或public HashMap(int initialCapacity)
（3）哈希表为空，oldThr为0，说明未初始化threshold，直接使用默认值更新newCap和newThr；对应构造函数
（4）使用newThr更新threshold
oldTable为空，直接返回创建好的newTable
oldTable不为空，需要遍历桶中的entry，将这些entry放置到正确的位置（桶下表可能不变，可能增加oldCap）

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length; // 哈希表为空
    int oldThr = threshold; // 对应当前的threshold
    int newCap, newThr = 0;
    if (oldCap > 0) { // 情况1：表不为空，要么不扩容，要么扩容2倍
        if (oldCap >= MAXIMUM_CAPACITY) {  // 情况1.1： >= 最大容量，不扩容
            threshold = Integer.MAX_VALUE; // 将threshold设置为最大值，size无法再触发扩容
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY) // 情况1.2：未超过最大值，将Capacity和threshold都扩容2倍
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // 情况2：表为空，指定了initialCapacity，使用threshold中保存的initialCapacity更新newCap
        newCap = oldThr;
    else {  // 情况3： 表为空，未指定initialCapacity；直接使用默认值，更新newCap和newThr
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) { // 针对情况2，未更新newThr，需要进行补充更新
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr; // 使用newThr更新threshold
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) { // 表不为空，容量翻倍后，需要更桶中新节点的位置
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) { // 桶中存在节点
                oldTab[j] = null;
                if (e.next == null) // 桶中只有一个节点，直接更新
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode) // 基于红黑树的更新
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // 基于链表的更新
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {  // 对应bit值为0，则保持原位；否则，index增加oldCap
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) { // 保持原位的节点归位
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) { // 移动后的节点归位
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

为何分离的后链表，一部分放在原index的位置，一部分放在index + oldCap的位置？

假设，oldCap为16，扩容后newCap为32
原始的hash为5，其第5 bit为0；使用5 & (32 - 1)，计算出来的新index仍然为5 —— 保持原index不变

原始的hash为21，其第5 bit为1；使用21 & (32 - 1)，计算出来的新index为21 —— 原始index + oldCap

capacity为16，对应的 n - 1为 01111
hash: 5, index: 00101 & 01111 = 00101 = 5
hash: 21,index：10101 & 01111 = 00101 = 5 

capacity为32，对应的 n - 1为 11111
hash: 5, index: 00101 & 11111 = 00101 = 5
hash: 21,index：10101 & 11111 = 10101 = 21 = 5 + 16

总结： 当新的容量为 $2^n$ 时，hash的第n位为0，则其index保持不变；第n位为1，则其index变成 index + oldCap

4.5 总结

put()方法的实现，依靠putVal() 方法
putVal() 方法：
- 哈希表为空，通过扩容实现初始化；
- 否则，向对应桶按照红黑树或链表的结构，更新或插入节点；
- 其中，若插入节点后：链表长度大于8，执行树化操作；entry数目大于threshold，则进行扩容操作
treeifyBin()方法：链表长度大于8，不一定会转为红黑树，还要求哈希表的容量 >= MIN_TREEIFY_CAPACITY（64）
resize()方法：
- 先完成newCap和newThr的更新，从而更新threshold；
- 若oldTable不为空，需要遍历桶中的entry，更新entry的位置
- 桶位置的更新：不是重新计算 hash & (n - 1)，而是根据对应bit的值决定是保持原位，还是原位 + oldCap

5. remove方法

5.1 remove方法概述

有往HashMap中添加key-value的需求，就有从HashMap中删除key-value的需求
删除key-value，对应的是remove()方法
remove() 方法存在重载：（自己之前从未注意到）
- 一个是通过key删除key-value，一个是通过key和value删除key-value，即不仅要key匹配，还需要value也匹配才会删除
- 前者，返回key映射的value或null（不存在key的映射）；后者，是JDK1.8 Map接口新增方法，返回true，表示成功删除key-value
- 后者是JDK 1.8的新增方法，也难怪自己从未注意到了 😂
```
public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

public boolean remove(Object key, Object value) {
    return removeNode(hash(key), key, value, true, true) != null;
}
```
不管是哪种 remove 方法，其内部都调用的是removeNode()方法
猜想一下 removeNode() 方法的代码逻辑：
- 通过hash确定桶位置，然后遍历桶中的entry，找到key对应的entry；
- 如果不要求value要匹配，则直接删除并返回entry；否则，value要匹配，才能删除并返回entry
- 若没有对应的entry或value不匹配，则直接返回null

removeNode() 方法代码如下：

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) { // 桶中存在entry，遍历查找key对应的entry
        Node<K,V> node = null, e; K k; V v;
        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);
            }
        }
        // 删除entry
        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) // entry是首节点
                tab[index] = node.next;
            else // entry不是首节点，更新其前驱节点p的指向实现删除
                p.next = node.next;
            // 结构变化，返回被被删除的entry
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null; 
}

5.2 红黑树何时退回链表？

remove节点时，如果是红黑树节点，很可能会使得节点数小于6，这时红黑树需要退回链表？
红黑树退回链表的方法为untreeify()，实际调用这个方法的地方如下
仔细想想，removeTreeNode引发untreeify很正常，这个split又是干啥的？
split() 方法，在 resize() 方法中被调用，用于将红黑树按照upper和lower分成两部分，以实现rehash
也就是，按照新位置的计算方式，分为 index + oldCap、index两个位置的节点
如果split后，upper或lower中的节点数 <= UNTREEIFY_THRESHOLD（6），则进行untreeify操作
具体untreeify()方法如何实现的，这里不再深入探究

6. HashMap的遍历

最开始，还不了解HashMap的遍历方式时，自己遍历前都会上网查一下
自己能记住的有四种方式
- for-each遍历entrySet
- for-each遍历keySet
- for-each遍历values
- 迭代器遍历entrySet
这次系统学习，还有lambda表达是、stream API等

想要了解遍历方式，可以参考以下文档

遍历 HashMap 的 5 种最佳方式，我不信你全知道！
HashMap 的 7 种遍历方式与性能分析！ (通过entrySet或lambda表达式的性能更好，oracle的JMH框架)

6.1 基于entrySet的遍历

基于entrySet遍历HashMap，首先需要通过entrySet()方法获取entry集合

public Set<Map.Entry<K,V>> entrySet() {
    Set<Map.Entry<K,V>> es;
    return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}

HashMap中有一个EntrySet的实例变量entrySet，如果第一次访问entrySet()方法，会初始化entrySet变量

EntrySet类是HashMap的内部类

final class EntrySet extends AbstractSet<Map.Entry<K,V>>

EntrySet类中的forEach()方法，对应的就是for-each遍历

public final void forEach(Consumer<? super Map.Entry<K,V>> action)

iterator()方法：创建entrySet的迭代器，从而可以迭代访问entrySet

public final Iterator<Map.Entry<K,V>> iterator() {
    return new EntryIterator();
}

如果使用迭代器遍历，遍历过程中删除entry，不会触发fail-fast机制；如果使用for-each遍历，会检查modCount是否发生变化，从而触发fail-fast机制、抛出ConcurrentModificationException

6.2 基于keySet或values的遍历

基于keySet或values的遍历也是如此，既支持for-each遍历，又支持迭代器遍历，都采用fail-fast机制
- 除非使用迭代器的remove方法，其他任何改变HashMap结构的方法都将使得迭代器抛出ConcurrentModificationException异常
下面的代码，测试了对key的for-each和迭代器遍历修改map结构的情况

根据执行结果可知，只有迭代器的remove方法修改map结构才不会触发ConcurrentModificationException异常

public static void keyRemove(Map<String, String> map){
    // 通过foreach删除元素，触发ConcurrentModificationException
    for (String key: map.keySet()) {
        if ("2".equals(key)) {
            map.remove(key);
        }
    }
}

public static void keyAdd(Map<String, String> map){
    // 通过foreach添加元素，触发ConcurrentModificationException
    for (String key: map.keySet()) {
        if ("2".equals(key)) {
            map.put("add", "16");
        }
    }
}

public static void keyRemoveByIterator(Map<String, String> map){
    // 通过迭代器删除元素，不会触发ConcurrentModificationException
    Iterator<String> iterator = map.keySet().iterator();
    while (iterator.hasNext()){
        if ("1".equals(iterator.next())){
            iterator.remove();
        }
    }
}
public static void keyAddByIterator(Map<String, String> map){
    // 通过迭代器删除元素，不会触发ConcurrentModificationException
    Iterator<String> iterator = map.keySet().iterator();
    while (iterator.hasNext()){
        if ("1".equals(iterator.next())){
            map.put("add", "16");
        }
    }
}