Java Map 常用方法与核心实现类深度解析

设计哲学解读

为什么默认负载因子是 0.75？这是时间与空间的折中选择。过高会导致 Hash 碰撞增加，过低则浪费空间。为什么容量必须是 2 的 n 次幂？这涉及核心优化：计算下标时 (n - 1) & hash 等价于 hash % n，位运算速度远快于取模，且能充分利用 hash 值的所有位减少碰撞。

put 方法执行流程

put 方法是理解 HashMap 的关键入口：

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. 数组延迟初始化：首次 put 时创建数组
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 2. 计算下标，如果该位置为空直接插入
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 3. 处理 Hash 冲突
        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;
                }
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // 4. 找到相同 key，替换 value
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 5. 检查是否需要扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

执行流程总结：计算 hash 值 -> 计算数组下标 -> 空则插入 -> 冲突则遍历 -> 找到则替换 -> 检查树化或扩容。

扩容机制（resize）

当元素个数超过 threshold = capacity * loadFactor 时，HashMap 会进行扩容。JDK 8 采用尾插法，避免 JDK 7 头插法在多线程环境下产生的循环链表问题。元素迁移时，无需重新计算 hash，只需看 e.hash & oldCap 是否为 0，为 0 则留在原位，否则移到 原位置 + oldCap。

线程安全问题

HashMap 是线程不安全的。多线程环境下可能出现数据覆盖、size 不准确、JDK 7 扩容死循环等问题。解决方案是使用 Collections.synchronizedMap(new HashMap<>()) 或推荐使用 ConcurrentHashMap。

LinkedHashMap：保持插入顺序

LinkedHashMap 继承自 HashMap，通过双向链表维护元素的顺序。

数据结构特点

在 HashMap 的 Node 基础上增加了 before 和 after 指针，构成了双向链表，用于记录元素的插入顺序或访问顺序。

两种排序模式

1. 插入顺序（默认）：按元素首次插入 Map 的顺序迭代。
2. 访问顺序：按元素最近被访问（get/put）的时间从旧到新迭代。

// 指定访问顺序
Map<String,String> map = new LinkedHashMap<>(16, 0.75f, true);
map.put("a", "1");
map.put("b", "2");
map.get("a"); // 访问 a，a 会被移动到链表尾部
// 迭代顺序：b, a（最近访问的在最后）

实现 LRU 缓存

利用访问顺序模式，可以轻松实现 LRU 缓存：

class LRUCache<K,V> extends LinkedHashMap<K,V> {
    private final int maxCapacity;
    public LRUCache(int maxCapacity) {
        super(16, 0.75f, true); // 启用访问顺序
        this.maxCapacity = maxCapacity;
    }
    @Override
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return size() > maxCapacity; // 超过容量时移除最久未访问的元素
    }
}

TreeMap：基于红黑树的排序 Map

TreeMap 实现了 SortedMap 和 NavigableMap 接口，底层基于红黑树实现，能够对键进行排序。

排序机制

TreeMap 要求键要么实现 Comparable 接口（自然排序），要么在构造时提供 Comparator（定制排序）。

// 自然排序：键必须实现 Comparable
TreeMap<Integer,String> naturalMap = new TreeMap<>();
// 定制排序：提供 Comparator
TreeMap<String,Integer> customMap = new TreeMap<>((s1, s2) -> s2.compareTo(s1)); // 降序

核心方法

TreeMap 提供了丰富的导航方法，如 firstKey、lastKey、lowerKey、floorKey 等，支持子 Map 视图操作。

注意事项

1. 键不能为 null：因为无法比较 null。
2. compareTo 与 equals 需一致：当两个键比较结果为 0 时，TreeMap 认为它们相等。
3. 字符串键的特殊性：字符串排序按字典序，数字字符串排序时需注意，如 "22" 会排在 "5" 前面。

Hashtable 与 Properties

Hashtable：古老的线程安全 Map

Hashtable 是 JDK 1.0 就存在的古老实现类，所有方法都用 synchronized 修饰，不允许 null 键和 null 值。虽然线程安全，但全表锁导致并发性能差。

Properties：处理配置文件

Properties 继承自 Hashtable，专门用于处理配置文件，键和值都是 String 类型。常用方法包括 load、store、getProperty 等。

ConcurrentHashMap：并发编程的利器

ConcurrentHashMap 是 Java 并发包中提供的线程安全且高性能的 Map 实现。

设计哲学

在保证线程安全的同时，提供比 Hashtable 更高的并发性能。JDK 7 采用分段锁，JDK 8+ 改用 CAS + synchronized 实现，锁粒度更细，读操作完全无锁。

JDK 8+ 实现：CAS + synchronized

放弃分段锁，与 HashMap 结构对齐。只锁住链表或红黑树的头节点。putVal 核心片段展示了如何通过 CAS 尝试插入，失败则同步锁住头节点进行操作。

弱一致性迭代器

迭代器创建后，如果 Map 发生修改，不会抛出 ConcurrentModificationException。迭代器反映的是创建时刻或之后某个时刻的数据快照，适用于高并发场景。

批量操作

ConcurrentHashMap 提供了强大的批量操作 API，如 forEach、search、reduce 等，支持并行执行。

Map 常用方法详解

基础操作方法

• put(K key, V value)：添加键值对。
• get(Object key)：根据 key 获取 value。
• remove(Object key)：删除键值对。
• clear()：清空所有键值对。
• size()：返回键值对数量。

查询方法

• containsKey(Object key)：判断是否包含指定键。
• containsValue(Object value)：判断是否包含指定值。
• getOrDefault(Object key, V defaultValue)：获取值，不存在则返回默认值。

遍历方法

Map 的遍历方式多样，可根据场景选择：

1. entrySet 遍历（最常用）：

for(Map.Entry<String,Integer> entry : map.entrySet()){
    System.out.println(entry.getKey()+": "+ entry.getValue());
}

2. keySet + get 遍历：效率较低，每次 get 都需要二次查找。
3. values 遍历（仅需值时）：

for(Integer value : map.values()){
    System.out.println(value);
}

4. Iterator 遍历（支持 remove）：

Iterator<Map.Entry<String,Integer>> iterator = map.entrySet().iterator();
while(iterator.hasNext()){
    Map.Entry<String,Integer> entry = iterator.next();
    if(entry.getValue()<0){
        iterator.remove(); // 安全删除
    }
}

5. Java 8 forEach（最简洁）：

map.forEach((key, value)->System.out.println(key +": "+ value));

6. Stream API 遍历（支持链式操作）：

map.entrySet().stream().filter(entry -> entry.getValue()>10).forEach(entry ->System.out.println(entry.getKey()));

Java 8+ 新增的默认方法

Java 8 在 Map 接口中增加了多个实用默认方法，极大地简化了代码：

• computeIfAbsent / computeIfPresent：如果 key 不存在则通过函数计算 value 并放入 Map。

map.computeIfAbsent("key", k -> new ArrayList<>()).add("value");

• merge 方法：合并操作，如果 key 不存在则放入给定值，存在则通过合并函数计算新值。

map.merge("key", 1, Integer::sum);

• putIfAbsent：仅在 key 不存在时放入。
• replace / replaceAll：替换指定 key 的值或对所有 entry 应用替换函数。

Java 9 的 Map.of 工厂方法

Java 9 提供了更简洁的 Map 初始化方式，创建不可变 Map。

实现类对比与选型指南

核心特性对比

时间复杂度对比

选型建议

• 场景 1：通用缓存，无特殊顺序要求：首选 HashMap，如需线程安全选 ConcurrentHashMap。
• 场景 2：需要保持插入顺序：首选 LinkedHashMap。
• 场景 3：需要按键排序或范围查询：首选 TreeMap。
• 场景 4：实现 LRU 缓存：首选 LinkedHashMap（访问顺序模式）。
• 场景 5：高并发共享数据：首选 ConcurrentHashMap。
• 场景 6：处理配置文件：首选 Properties。

常见陷阱与最佳实践

陷阱一：可变对象作为键

使用可变对象作为键会导致 hashCode 改变，从而无法找到对应的值。解决方案是使用不可变对象作为键，如 String、Integer。

陷阱二：自定义类未重写 hashCode 和 equals

作为键的类必须正确重写 hashCode() 和 equals()，否则即使内容相同也无法匹配。

陷阱三：并发修改导致 ConcurrentModificationException

在 foreach 循环中直接调用 map.remove() 会抛出异常。解决方案是使用 Iterator 的 remove 方法，或使用 removeIf（Java 8+），或使用 ConcurrentHashMap。

最佳实践总结

1. 使用泛型：指定键值类型，避免运行时类型转换异常。
2. 选择合适的实现：根据业务需求而非习惯选择。
3. 注意线程安全：多线程环境优先使用 ConcurrentHashMap。
4. 避免使用 Hashtable：除非维护遗留代码。
5. 预估初始容量：如果能预知数据规模，指定初始容量避免频繁扩容。

结语

Java Map 体系经过多年的演进，已经形成了一套功能完备、性能卓越的数据结构家族。理解 Map 的核心原理，不仅有助于写出更高效的代码，还能在遇到复杂业务场景时做出正确的技术选型。在实际开发中，建议遵循'面向接口编程'的原则，根据具体需求选择最合适的 Map 实现，同时注意线程安全和键的不可变性等关键问题。