HashMap 高频面试题全解：null key、遍历顺序、线程安全

static final int hash(Object key) {
    int h;
    // key == null → 直接返回 0，不调用 hashCode()
    return (key == null) ? 0
         : (h = key.hashCode()) ^ (h >>> 16);
}

if (key == null || value == null)
    throw new NullPointerException();  // 没有任何商量

Map<String, Integer> map = new HashMap<>();
map.put("apple",  1);
map.put("banana", 2);
map.put("cherry", 3);
map.put("date",   4);

// 遍历结果（取决于 hashCode 和数组长度）：
// 可能是 banana, apple, date, cherry —— 和插入顺序完全不同
for (String key : map.keySet()) {
    System.out.println(key + " → " + map.get(key));
}

static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after;  // 双向链表的前后指针
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

class User {
    String name;
    int age;

    User(String name, int age) {
        this.name = name; this.age = age;
    }

    // 只重写了 equals，没重写 hashCode —— 这是一个 Bug
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User u = (User) o;
        return age == u.age && name.equals(u.name);
    }
    // hashCode() 继承 Object —— 基于内存地址，每次 new 都不同
}

Map<User, String> map = new HashMap<>();
User u1 = new User("Alice", 25);
User u2 = new User("Alice", 25);

map.put(u1, "VIP");
System.out.println(u1.equals(u2));        // true —— equals 认为相等
System.out.println(map.get(u2));           // null —— 但 HashMap 找不到！
// 原因：u1 和 u2 的 hashCode 不同，落到了不同的桶

// 典型事故场景：全局缓存使用 HashMap
public class CacheService {
    // ❌ 错误：多线程环境用了 HashMap
    private Map<String, Object> cache = new HashMap<>();

    public void refreshCache(List<Config> configs) {
        // 多个线程同时调用 → 并发 put → 触发并发 resize
        configs.forEach(c -> cache.put(c.getKey(), c.getValue()));
    }
}

// 修复方案：替换为 ConcurrentHashMap
private Map<String, Object> cache = new ConcurrentHashMap<>();

class Key {
    String value;
    public int hashCode() { return value.hashCode(); }
    public boolean equals(Object o) {
        return o instanceof Key && value.equals(((Key)o).value);
    }
}

Map<Key, String> map = new HashMap<>();
Key k = new Key();
k.value = "hello";
map.put(k, "world");

k.value = "changed";    // 修改了影响 hashCode 的字段
System.out.println(map.get(k));  // null —— 找不到！
// 原因：put 时 k 在 hash("hello") 对应的桶里
// get 时用 hash("changed") 去查，去了完全不同的桶

// ❌ 默认容量 16，存 1000 个元素会触发多次扩容
Map<String, Object> bad = new HashMap<>();

// ✅ 正确：预估元素数量，指定初始容量
int expectedSize = 1000;
Map<String, Object> good = new HashMap<>(
    (int)(expectedSize / 0.75f) + 1
);

// ✅ 更简洁：Google Guava
Map<String, Object> guava = Maps.newHashMapWithExpectedSize(1000);

// Java 9+ Map.of() —— 不可变，不允许 null key/value
Map<String, Integer> config = Map.of(
    "timeout",  3000,
    "retries",  3,
    "poolSize", 10
);

// Map.copyOf() —— 从已有 Map 创建不可变副本
Map<String, Integer> snapshot = Map.copyOf(config);

// config.put("new", 1)  → UnsupportedOperationException
// Map.of("key", null)   → NullPointerException