在 Java 中，`HashMap` 和 `Hashtable` 都是用于存储键值对的集合类，但它们有很多不同点和特性，适用于不同的使用场景。以下是 `HashMap` 和 `Hashtable` 的详细对比和介绍。
### 1. `HashMap` 概述
- `HashMap` 是基于哈希表实现的 `Map` 接口，它允许存储 `null` 值和 `null` 键。
- 它是非同步的（线程不安全），多个线程同时访问时可能出现不一致的问题。
- `HashMap` 的存储顺序是无序的，不能保证元素的顺序。
- Java 1.8 之后，`HashMap` 引入了红黑树的结构来优化处理哈希冲突，提高查找性能。
#### 代码示例：
```java
import java.util.HashMap;
import java.util.Map;
public class HashMapExample {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);
map.put(null, 100); // 允许null键
map.put("Charlie", null); // 允许null值
// 遍历HashMap
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}
```
#### `HashMap` 的主要特性：
1. **允许 `null` 键和值**：
- `HashMap` 允许一个 `null` 键和多个 `null` 值。
2. **非同步**：
- `HashMap` 不是线程安全的。如果多个线程同时修改 `HashMap`，可能导致数据不一致。
- 可以通过使用 `Collections.synchronizedMap()` 方法将 `HashMap` 包装为同步的版本。
3. **性能**：
- `HashMap` 的操作（插入、删除、查找）平均时间复杂度是 O(1)，但在最坏情况下（大量哈希冲突）可能退化为 O(n)。
4. **扩容机制**：
- 当 `HashMap` 中的元素数量超过初始容量的 75% 时，它会自动进行扩容，增加存储容量以减少哈希冲突。
### 2. `Hashtable` 概述
- `Hashtable` 是一个古老的类，从 Java 1.0 就开始存在。
- 它也是基于哈希表实现的，但它是同步的，所有的方法都使用了 `synchronized` 关键字，线程安全。
- `Hashtable` 不允许 `null` 键或 `null` 值。
- 和 `HashMap` 一样，`Hashtable` 也没有顺序性，不保证元素的插入顺序。
#### 代码示例：
```java
import java.util.Hashtable;
public class HashtableExample {
public static void main(String[] args) {
Hashtable<String, Integer> table = new Hashtable<>();
table.put("Alice", 25);
table.put("Bob", 30);
// table.put(null, 100); // 不能使用null键
// table.put("Charlie", null); // 不能使用null值
// 遍历Hashtable
for (String key : table.keySet()) {
System.out.println(key + ": " + table.get(key));
}
}
}
```
#### `Hashtable` 的主要特性：
1. **不允许 `null` 键和值**：
- 在 `Hashtable` 中，任何 `null` 键或 `null` 值都会抛出 `NullPointerException`。
2. **线程安全**：
- `Hashtable` 的所有方法都是同步的，这意味着它是线程安全的，适合在多线程环境中使用。
- 但由于同步开销，性能比 `HashMap` 慢。
3. **过时**：
- `Hashtable` 属于早期的集合框架，现在通常建议使用 `ConcurrentHashMap` 代替它。
4. **性能**：
- 由于所有操作都是同步的，`Hashtable` 的性能比 `HashMap` 慢。在单线程或低并发环境中，不推荐使用 `Hashtable`。
### 3. `HashMap` vs `Hashtable` 对比
| 特性 | `HashMap` | `Hashtable` |
|------------------|------------------------------------|----------------------------------|
| **线程安全** | 否，非同步 | 是，所有方法都同步 |
| **允许 `null`** | 允许 `null` 键和 `null` 值 | 不允许 `null` 键和 `null` 值 |
| **性能** | 比 `Hashtable` 更快 | 因同步开销，性能较慢 |
| **引入版本** | Java 1.2 | Java 1.0 |
| **适用场景** | 适合单线程或需要高性能的多线程环境 | 适合需要线程安全的环境 |
| **替代方案** | `ConcurrentHashMap` 可替代 | `ConcurrentHashMap` 是更好的选择 |
### 4. `ConcurrentHashMap` —— 更好的选择
`ConcurrentHashMap` 是 Java 5 引入的，用于替代 `Hashtable`，它通过分段锁的机制实现了高效的并发性。它既是线程安全的，同时也避免了全表锁的性能瓶颈。
#### `ConcurrentHashMap` 示例：
```java
import java.util.concurrent.ConcurrentHashMap;
public class ConcurrentHashMapExample {
public static void main(String[] args) {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);
map.put("Charlie", 35);
// 遍历ConcurrentHashMap
for (String key : map.keySet()) {
System.out.println(key + ": " + map.get(key));
}
}
}
```
#### 主要特性：
- **高效并发**：使用分段锁，多个线程可以并发执行读写操作。
- **性能优于 `Hashtable`**：没有全表锁，锁的粒度更细。
- **线程安全**：提供了线程安全的操作，同时避免了同步化的性能损失。
### 5. 结论
- `HashMap` 是在大多数场景下的最佳选择，特别是在不需要线程安全的场景中。
- 如果需要线程安全，推荐使用 `ConcurrentHashMap`，而不是传统的 `Hashtable`，因为它在性能和可扩展性上有更好的表现。
- `Hashtable` 是一个老旧的类，已经逐渐被 `ConcurrentHashMap` 替代，几乎不再推荐使用。