HashMap 完整讲解：从源码到原理

什么是 HashMap？🧠

HashMap 是 Java 中非常常用的一种数据结构，它通过**键值对（key-value pairs）来存储数据。它的最大特点是通过哈希表（hashing）**实现了非常快的查找、插入和删除操作。

核心原理 🍰：

• 哈希表：HashMap 的底层数据结构是一个数组，数组中的每个位置称为 “桶”（bucket）。我们通过计算每个键的 hashCode()，把键和值放入对应的桶里。
• 哈希冲突：当多个键的哈希值相同，导致它们被放入同一个桶里，这就叫做“哈希冲突”。HashMap 通过链表（或红黑树）来处理这种冲突。

---

HashMap 是如何工作的？🛠️

1. put()：往 HashMap 里放东西 🛒

每当我们调用 put() 方法往 HashMap 里添加一个键值对时，它会经历以下几个步骤：

1. 计算哈希值 🔢：
   • HashMap 使用键的 hashCode() 方法来计算哈希值，这个哈希值会告诉我们这个键值对应该放在哪个桶里。
   • 例子：假如你往超市里添加一个新商品，比如苹果（key），苹果有一个编号12345（hashCode）。你通过这个编号决定它该放在哪个货架（bucket）上。
2. 查找对应的桶 📦：
   • 通过哈希值找到对应的桶。如果这个桶是空的（还没有放东西），直接把键值对放进去。
   • 例子：你走到货架5号，发现货架是空的，就直接把苹果放上去。
3. 处理哈希冲突 🔗：
   • 如果这个桶已经有东西了（发生了哈希冲突），HashMap 会以链表的方式将新的键值对加到这个桶的末尾。
   • 例子：如果货架5号已经有其他商品了，那你就只能把苹果放到它后面，排队（链表结构）。
4. 链表转红黑树 🌳：
   • 如果一个桶里存的东西太多了（链表太长），HashMap 会把链表转换为红黑树，以提高查找效率。
   • 例子：如果排队的人太多了，超市可能会重新安排，采用更高效的方式摆放商品（红黑树），这样你找商品的时候可以更快。
5. 扩容 🛠️：
   • 当 HashMap 的大小（存储的键值对的数量）超过了它的容量阈值，HashMap 会自动扩容，增加桶的数量，并重新分配现有的键值对到新的桶里。
   • 例子：当货架快满的时候，你决定扩展超市，买更多的货架，把现有的商品重新分布到更大的空间里。

---

2. get()：从 HashMap 里取东西 🔍

当我们需要从 HashMap 中查找某个键对应的值时，它会执行以下操作：

1. 计算哈希值：
   • HashMap 首先会根据键的 hashCode() 计算出它的哈希值，找到对应的桶。
2. 遍历桶里的元素：
   • 如果这个桶里有多个元素（哈希冲突），它会遍历链表或红黑树，找到匹配的键。
3. 返回值：
   • 一旦找到匹配的键，就会返回它对应的值；如果没找到，就返回 null。

例子：你来到超市想买苹果，你先找到货架5号，然后依次查看货架上的商品，找到你要的苹果。

---

核心源码解析 🍔

public V put(K key, V value) {
    // 调用 putVal 方法，传入 key 和 value。
    // 这里是实际执行键值对插入操作的地方。
    return putVal(hash(key), key, value, false, true);
}

private V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; 
    Node<K,V> p; 
    int n, i;
    
    // 如果 HashMap 还没有创建数组，或者数组长度为 0，则扩容（创建新的货架）。
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;  // 调用 resize 方法扩容
    
    // 通过哈希值计算出桶的位置。如果该位置为空，就直接放入新节点。
    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;  // 找到了这个旧的节点，准备替换它的值。
        // 如果这个节点是红黑树节点，那就调用红黑树的插入方法。
        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)
                        treeifyBin(tab, hash);  // 链表转成红黑树
                    break;
                }
                // 如果在链表中发现了相同的 key，那就不用新增节点了，准备更新值。
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;  // 继续往链表的下一个节点走
            }
        }
        // 如果找到了相同的键，更新它的值并返回旧值。
        if (e != null) {  
            V oldValue = e.value;  // 获取旧值
            e.value = value;  // 替换为新值
            return oldValue;  // 返回旧值
        }
    }
    
    // 每次成功插入新节点后，HashMap 的修改次数加一。
    ++modCount;
    
    // 如果 HashMap 的大小超过了阈值，就需要扩容。
    if (++size > threshold)
        resize();  // 扩容：增加数组的大小
    
    return null;  // 返回 null 表示插入成功，没有旧值被替换
}

总结🎉：

1. HashMap 通过键的 hashCode() 来决定把键值对存放在哪个“桶”里。如果发生哈希冲突，就会把多个键值对存在同一个桶里，使用链表（或红黑树）来管理这些冲突。
2. 扩容机制 保证了当数据量增大时，HashMap 能自动增加空间，让查找和插入操作保持高效。
3. 链表转红黑树 是为了优化性能，当一个桶里有太多键值对时，链表会自动转换成红黑树，进一步加快查找的速度。

** 🏆**

操作	过程
插入（put）	计算哈希值 -> 找到对应的桶 -> 如果冲突，处理链表或红黑树 -> 如果太多元素，扩容
查找（get）	计算哈希值 -> 找到对应的桶 -> 遍历链表或红黑树找到相应的键
扩容（resize）	创建更大的数组 -> 重新分配所有键值对到新的数组
哈希冲突处理	使用链表存储冲突的键值对 -> 链表过长时转换为红黑树
查找效率	理想情况下是 O(1)，在最坏情况下（大量冲突）下是 O(log n)（如果使用红黑树），仍然很快

---