Java8 HashMap 学习笔记

最新推荐文章于 2024-10-02 21:20:07 发布

qokaerxn

最新推荐文章于 2024-10-02 21:20:07 发布

阅读量842

点赞数 15

文章标签：学习笔记 java

本文链接：https://blog.csdn.net/m0_61710468/article/details/142532153

版权

灵感来源：小林coding（Java集合面试题 | 小林coding (xiaolincoding.com)）;Java全栈知识体系（Map - HashSet & HashMap 源码解析 | Java 全栈知识体系 (pdai.tech)）；黑马程序员视频（集合进阶-13-HashMap源码超详细解析（一）_哔哩哔哩_bilibili）。

1.HashMap属性

    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 初始默认桶数组初始容量大小为16

    static final int MAXIMUM_CAPACITY = 1 << 30; //桶数组最大容量大小为1<<30=2^30=1,073,741,824

    static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认负载因子

    static final int TREEIFY_THRESHOLD = 8;//桶中链表转红黑树阈值（由小变大）

    static final int UNTREEIFY_THRESHOLD = 6;//桶中红黑树转链表阈值（由大变小）
    
    static final int MIN_TREEIFY_CAPACITY = 64;//链表转红黑数所需满足的桶数组最小值

    transient Node<K,V>[] table;//桶数组

    transient Set<Map.Entry<K,V>> entrySet;//所有映射条目（键值对）

    transient int size;//映射条目数量

    transient int modCount;//结构修改次数

    int threshold;//扩容阈值

    final float loadFactor;//负载因子

MAXIMUM_CAPACITY：
- 静态最终（static final）整数，值为 1 << 30，即 1,073,741,824。
- 这是 HashMap 能支持的最大容量。超过这个容量，HashMap 将无法再进行扩容。
DEFAULT_LOAD_FACTOR：
- 静态最终（static final）浮点数，值为 0.75f。
- 这是 HashMap 的默认负载因子，用于确定何时进行扩容。
TREEIFY_THRESHOLD：
- 静态最终（static final）整数，值为 8。
- 这是链表转换为红黑树的阈值。当链表的长度达到 8 时，链表将被转换为红黑树。
UNTREEIFY_THRESHOLD：
- 静态最终（static final）整数，值为 6。
- 这是红黑树转换回链表的阈值。当红黑树的节点数量低于 6 时，树将被转换回链表。
MIN_TREEIFY_CAPACITY：
- 静态最终（static final）整数，值为 64。
- 这是桶数组的最小容量，用于链表转换为红黑树之前，确保桶数组的容量至少为 64。
table：
- transient 关键字表示这个数组不会被序列化。
- Node<K,V>[] 类型的数组，用于存储映射的键值对。
- 每个数组元素是一个桶，可以包含一个或多个通过链表或红黑树链接的节点。
entrySet：
- transient 关键字表示这个集合不会被序列化。
- 这个集合包含了 HashMap 中的所有映射条目（键值对）。
size：
- transient 关键字表示这个变量不会被序列化。
- 整数，表示 HashMap 中当前的映射条目数量。
modCount：
- transient 关键字表示这个变量不会被序列化。
- 用于记录结构性修改的次数，可以被迭代器用于检测 HashMap 在迭代过程中是否发生了修改。
threshold：
- 整数，定义了 HashMap 进行扩容的阈值。当 HashMap 中的元素数量超过这个阈值时，会触发扩容操作。
loadFactor：
- final 关键字表示这个变量一旦被初始化后，其值就不能被改变。
- 浮点数，定义了 HashMap 的负载因子。它是一个性能相关的参数，用于计算何时进行扩容操作。扩容阈值是 loadFactor 与当前桶数组容量的乘积。

2.HashMap的put(K,V)方法

1.K为键，V为值。可以看到他里面用到了putVal(hash(key), key, value, false, true)方法。


/*参数K为键，V为值*/
public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

//计算hash值并返回，如果key为null那么返回0，否则返回计算值
static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

//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;
            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);
                        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;
    }

参数解释：
- hash：键的哈希码。key：要存储的键。
- value：与键关联的值。
- onlyIfAbsent：如果为 true，则只有当键不存在时才更新值。
- evict：用于控制是否需要考虑替换旧值。
局部变量：
- tab：指向当前桶数组的引用。
- p：用于遍历链表或红黑树的当前节点。
- n：桶数组的长度。
- i：计算出的插入位置索引。
数组初始化和扩容：
- 如果 table 为 null 或者长度为 0，那么进行扩容操作resize()，并重新获取桶数组的长度。
```
if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
```

空桶的插入：

在该位置创建一个新的Entry对象来存储键值对，保存在桶数组相应的位置；将HashMap的修改次数（modCount）加1，以便在进行迭代时发现并发修改。

if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);

Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
        return new Node<>(hash, key, value, next);
    }

++modCount;

处理哈希冲突：
- 如果 p 不为 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)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
```

链表处理：

如果当前节点不是红黑树节点，那么遍历链表，寻找相同的键值对。
在遍历过程中，如果找到 null，说明链表在该位置断裂，可以插入新节点。

如果链表长度达到阈值 TREEIFY_THRESHOLD，则会将链表转换为红黑树。

else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        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;
                }
            }

更新现有键值对：

如果找到现有的键值对（即 e != null），则根据 onlyIfAbsent 参数决定是否更新值。

如果不更新，则通过 afterNodeAccess 方法通知节点访问。

if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }

扩容检查：
- 插入新节点后，检查 HashMap 的大小是否超过了扩容阈值，如果超过，则进行扩容。
```
if (++size > threshold)
            resize();
```
插入后处理：
- 调用 afterNodeInsertion 方法，该方法可以用于清除或标记节点，取决于 evict 参数。
```
afterNodeInsertion(evict);
```
返回值：
- 如果替换了现有键的值，则返回旧值。
- 如果插入了新键值对，则返回 null。