来源：网络
从入门到底层，一文打通两种核心数据结构
无论是在 Java 还是 Python 中，键值对（Key-Value） 存储结构都是日常开发中使用频率最高的数据结构之一。
Java 中叫 Map，Python 中叫 字典（dict）。它们看似“长得很像”，但背后的设计哲学、用法细节、性能特性却有着微妙的差异。
今天这篇文章，我会从初学者视角出发，逐步深入到底层实现和进阶用法，带你全面吃透两者的异同。全文配有大量代码示例，全部可运行，放心食用。
一、初识：它们是什么？
Map 是 Java 中 java.util 包下的一个接口，定义了键值对存储的规范。常用实现类有 HashMap、TreeMap、LinkedHashMap 等。
字典（dict） 是 Python 内置的数据类型，使用大括号 {} 表示，是一种可变、无序（Python 3.7+ 改为插入顺序）的键值对集合。
直观对比：
// Java
Map<String, Integer> map = new HashMap<>();
map.put("apple", 10);
map.put("banana", 5);
System.out.println(map.get("apple")); // 10
# Python
d = {}
d["apple"] = 10
d["banana"] = 5
print(d["apple"]) # 10
可以看到，基本操作（存、取）语法不同，但语义相似。
二、核心相似点（初学者必知）
1. 都基于键值对存储
两者都通过唯一的键来映射到对应的值，键不能重复，值可以重复。
2. 都支持快速查找
底层都使用哈希表（或红黑树，取决于实现），平均时间复杂度 O(1) 的查找性能。
3. 键必须是不可变类型（有例外说明）
- Python：键必须是**可哈希（hashable）**的，即不可变类型（如
str、int、tuple 等），列表 list 不能作为键。 - Java：键的类必须正确重写
hashCode() 和 equals() 方法，否则无法保证查找正确性。可变对象作为键时，若修改了内容会导致哈希值变化，从而“丢失”该键（强烈建议使用不可变键）。
4. 支持遍历
两者都支持遍历键、值、键值对。
三、主要差异（进阶重点）
差异1：类型安全 vs 动态灵活
Java 的 Map 是泛型的，编译期会检查键和值的类型：
Map<String, Integer> map = new HashMap<>();
map.put("age", 30); // OK
// map.put(30, "age"); // 编译错误
Python 的字典是动态类型，任何类型都可作为键或值，同一个字典里可以混合：
d = {
"name": "Tom",
100: "number",
(1,2): "tuple key"
}
print(d[100]) # "number"
进阶建议：Java 的强类型在大型项目中更安全，Python 的灵活性在小脚本和快速原型中更高效。
差异2：默认行为（有序性）
Java LinkedHashMap：按插入顺序。
Java TreeMap：按键的自然顺序或自定义比较器排序。
Python dict（3.7+）：保证插入顺序（这是官方特性）。
代码示例：
// Java 无序 vs 有序
Map<String, String> hashMap = new HashMap<>();
hashMap.put("b", "B");
hashMap.put("a", "A");
hashMap.put("c", "C");
System.out.println(hashMap); // 可能输出 {a=A, b=B, c=C} 或任意顺序
Map<String, String> linkedMap = new LinkedHashMap<>();
linkedMap.put("b", "B");
linkedMap.put("a", "A");
linkedMap.put("c", "C");
System.out.println(linkedMap); // 始终 {b=B, a=A, c=C}
# Python 3.7+
d = {}
d["b"] = "B"
d["a"] = "A"
d["c"] = "C"
print(d) # {'b': 'B', 'a': 'A', 'c': 'C'} 顺序保持插入顺序
差异3：访问不存在的键
- Java Map：
get(key) 返回 null（如果值允许为 null）或者 getOrDefault 默认值。 - Python dict：直接用
d[key] 会抛出 KeyError；安全做法是用 d.get(key, default)。
Map<String, Integer> map = new HashMap<>();
System.out.println(map.get("missing")); // null
System.out.println(map.getOrDefault("missing", 0)); // 0
d = {}
# print(d["missing"]) # KeyError
print(d.get("missing", 0)) # 0
差异4：添加/更新元素
- Java：
put(key, value) 若键已存在则覆盖，返回旧值（或 null）。 - Python：
d[key] = value 若键已存在则覆盖，无返回值。
另外 Python 还支持 update() 合并字典，Java 可以用 putAll()。
d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}
d1.update(d2) # d1 变为 {'a':1, 'b':3, 'c':4}
Map<String, Integer> m1 = new HashMap<>(Map.of("a",1,"b",2));
Map<String, Integer> m2 = Map.of("b",3,"c",4);
m1.putAll(m2); // m1 变为 {a=1, b=3, c=4}
差异5：删除元素
- Java：
remove(key) 返回被删除的值，或者 remove(key, value) 仅在匹配时删除。 - Python：
pop(key) 返回被删除的值，del d[key] 无返回值，popitem() 删除并返回最后一个插入的键值对（LIFO）。
d = {"x": 10, "y": 20}
val = d.pop("x") # val=10
last = d.popitem() # last=('y', 20)
Map<String, Integer> m = new HashMap<>(Map.of("x",10,"y",20));
Integer val = m.remove("x"); // val=10
boolean removed = m.remove("y", 20); // true
差异6：遍历方式
Java 遍历 Map：
Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
// 1. entrySet
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + "=" + entry.getValue());
}
// 2. keySet + get
for (String key : map.keySet()) {
System.out.println(key + "=" + map.get(key));
}
// 3. forEach (Java 8+)
map.forEach((k, v) -> System.out.println(k + "=" + v));
Python 遍历字典：
d = {"A": 1, "B": 2}
# 1. items()
for k, v in d.items():
print(f"{k}={v}")
# 2. keys() + 取值
for k in d.keys():
print(f"{k}={d[k]}")
# 3. 直接迭代（默认是键）
for k in d:
print(f"{k}={d[k]}")
差异7：底层实现（进阶硬核）
- Java HashMap：数组 + 链表/红黑树（当链表长度 ≥8 且数组长度 ≥64 时树化）。初始容量16，负载因子0.75，扩容为2倍。
- Python dict：使用稀疏表（sparse table） 和 组合哈希表（combined table） 策略（CPython 3.11+ 采用
dict 基于 sttable 的“键值分离”设计，内存更紧凑）。扩容策略比 Java 更复杂（约 2 倍或更少）。
面试常问：为什么 Java HashMap 要树化？——防止哈希冲突严重时链表过长导致查找退化为 O(n)。Python 字典也有类似优化（但实现不同）。
差异8：并发支持
- Java 提供了
ConcurrentHashMap 用于高并发场景，Collections.synchronizedMap 提供同步包装。 - Python 的
dict 本身不是线程安全的，多线程环境下需要使用 threading.Lock 或 collections.defaultdict 等，但 GIL 限制了真正并行，通常只用在多线程读多写少场景。
四、实用技巧（新手老手都受用）
1. 默认值处理
Java：computeIfAbsent 懒加载计算
Map<String, List<Integer>> map = new HashMap<>();
map.computeIfAbsent("key", k -> new ArrayList<>()).add(10);
Python：defaultdict 或 setdefault
from collections import defaultdict
d = defaultdict(list)
d["key"].append(10) # 自动创建空列表
2. 合并多个 Map
Java 8+ merge 方法可以处理冲突：
map1.merge("key", 100, Integer::sum); // 如果存在则相加
Python 3.9+ 支持 | 运算符：
merged = d1 | d2 # 返回新字典，d2覆盖d1
d1 |= d2 # 原地更新
3. 只读视图
Java：Collections.unmodifiableMap(map)
Python：虽然没有内置，但可以 types.MappingProxyType(d) 创建只读代理。
五、对比总结表（收藏用）
| | |
|---|
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| getOrDefault / computeIfAbsent | defaultdict / setdefault / get |
六、实际使用建议
- 如果你在写 Java：优先用
HashMap，需要有序用 LinkedHashMap，需要排序用 TreeMap，需要并发用 ConcurrentHashMap。 - 如果你在写 Python：直接使用
dict 即可，99% 场景够用。需要自动默认值用 defaultdict，需要保持插入顺序（本来就保持）无需额外操作。
跨语言迁移时注意：
- 在 Java 中自定义类作为键时，务必重写
equals 和 hashCode（可用 IDE 自动生成） - 在 Python 中自定义类作为键时，需实现
__hash__ 和 __eq__
七、进阶彩蛋：性能对比小实验
下面是一个简单的非严谨测试，感受一下量级（基于 JDK 17 和 CPython 3.11）：
// Java 插入100万条
Map<Integer, Integer> map = new HashMap<>();
long start = System.nanoTime();
for (int i = 0; i < 1_000_000; i++) map.put(i, i);
long end = System.nanoTime();
System.out.println("Java HashMap 插入: " + (end - start) / 1e6 + " ms");
# Python 插入100万条
import time
d = {}
start = time.perf_counter_ns()
for i in range(1_000_000):
d[i] = i
end = time.perf_counter_ns()
print(f"Python dict 插入: {(end - start) / 1e6:.2f} ms")
通常 Java 会更快（JIT 编译），但 Python 的 dict 实现非常精巧，差距并不悬殊。实际开发中，IO 开销才是瓶颈，不必过度纠结。
结语
Map 和字典，一个严谨，一个灵活，但都在各自生态中扮演着不可替代的角色。
理解它们的异同，能让你在跨语言开发时少踩坑，也能让你对哈希表这一基础数据结构有更立体的认知。
长按或扫描下方二维码，免费获取 Python公开课和大佬打包整理的几百G的学习资料，内容包含但不限于Python电子书、教程、项目接单、源码等等
▲扫描二维码-免费领取
推荐阅读
PandasAI：用自然语言解锁数据分析的新范式
2026年9个最好的开源大模型
7个AI工程必备Python库
机器学习特征工程：缩放、编码、聚合、嵌入与自动化
