Java中HashMap及其相关类的底层原理与实现详解

// JDK 1.8 源码核心字段
public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    
    // 1. 核心数组（Node 数组，即哈希桶）
    transient Node<K,V>[] table;
    
    // 2. 实际元素个数
    transient int size;
    
    // 3. 扩容阈值（capacity * loadFactor）
    int threshold;
    
    // 4. 负载因子（默认 0.75）
    final float loadFactor;
    
    // 5. 静态内部类 Node（链表节点）
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;  // 指向下一个节点（链表指针）
    }
    
    // 6. 树化阈值（链表长度 >= 8 且数组长度 >= 64 时转红黑树）
    static final int TREEIFY_THRESHOLD = 8;
    
    // 7. 退树化阈值（红黑树节点数 <= 6 时退化为链表）
    static final int UNTREEIFY_THRESHOLD = 6;
    
    // 8. 最小树化容量
    static final int MIN_TREEIFY_CAPACITY = 64;
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 1. table 为空则初始化（resize）
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 2. 计算数组下标 (n - 1) & hash，若该位置为空则直接放入
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 3. 如果 key 相同（hash 相同 && (引用相同 || equals 为 true)）→ 覆盖
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 4. 如果已经是红黑树节点 → 走红黑树的 putTreeVal
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 5. 链表情况：遍历链表
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 5a. 如果链表长度 >= 8 → 尝试转红黑树
                    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;
            }
        }
        // 6. 覆盖旧值
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            return oldValue;
        }
    }
    ++modCount;  // 记录修改次数（用于 Fast-Fail）
    if (++size > threshold)  // 7. 超过阈值则扩容
        resize();
    return null;
}

static final int hash(Object key) {
    int h;
    // 让 hashCode 的高 16 位参与低 16 位的运算（混合扰动），减少哈希碰撞
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

// JDK 源码
public class HashSet<E> extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {
    
    private transient HashMap<E,Object> map;  // 底层就是 HashMap！
    
    // 虚拟占位值（所有 Value 都指向它）
    private static final Object PRESENT = new Object();
    
    // 构造方法（直接 new HashMap）
    public HashSet() {
        map = new HashMap<>();
    }
    
    // 添加元素：存到 map 的 Key 位置
    public boolean add(E e) {
        return map.put(e, PRESENT) == null;
    }
    
    // 删除元素
    public boolean remove(Object o) {
        return map.remove(o) == PRESENT;
    }
}

// 1. 插入顺序（默认）
LinkedHashMap<String, String> map1 = new LinkedHashMap<>();
map1.put("A", "1");
map1.put("B", "2");
map1.put("C", "3");
// 遍历输出：A, B, C（按插入顺序）

// 2. 访问顺序（accessOrder = true）
LinkedHashMap<String, String> map2 = new LinkedHashMap<>(16, 0.75f, true);
map2.put("A", "1");
map2.put("B", "2");
map2.put("C", "3");
map2.get("A");  // 访问 A，A 会被移动到链表尾部
// 遍历输出：B, C, A（最近访问的放在最后）

// 实现一个固定大小的 LRU 缓存
class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int maxSize;
    
    public LRUCache(int maxSize) {
        super(maxSize, 0.75f, true);  // accessOrder = true
        this.maxSize = maxSize;
    }
    
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        // 当元素数量超过最大容量时，自动移除最老的元素（链表头部）
        return size() > maxSize;
    }
}

// 使用示例
LRUCache<String, Integer> cache = new LRUCache<>(3);
cache.put("A", 1);
cache.put("B", 2);
cache.put("C", 3);
cache.get("A");  // 访问 A
cache.put("D", 4);  // 触发淘汰，淘汰最久未使用的 B
// 缓存中：C, A, D

// JDK 8+ 源码核心（putVal 方法片段）
final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();  // 禁止 null
    int hash = spread(key.hashCode());
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 1. 位置为空 → CAS 尝试插入（无锁）
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
                break;
        } else if ((fh = f.hash) == MOVED)
            // 2. 正在扩容 → 帮助迁移
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            // 3. 位置不为空 → synchronized 锁住头节点
            synchronized (f) {
                // ... 插入或覆盖逻辑
            }
            break;
        }
    }
    addCount(1L, binCount);
    return null;
}

// 问题 1：下面代码输出什么？为什么？
public static void main(String[] args) {
    HashSet<String> set = new HashSet<>();
    String s1 = new String("Hello");
    String s2 = new String("Hello");
    set.add(s1);
    set.add(s2);
    System.out.println(set.size());  // A
}

// 问题 2：下面代码在多线程环境下会有什么问题？
public class Test {
    private static final Map<String, String> map = new HashMap<>();
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                map.put(Thread.currentThread().getName(), "value");
            }).start();
        }
    }
}

// 问题 3：下面哪个 Map 最合适用来实现一个带有过期淘汰策略的缓存？
// A. HashMap   B. LinkedHashMap   C. ConcurrentHashMap   D. HashTable