HashMap<K, V> 是 Rust 标准库中的一种集合类型，它通过哈希函数将 K 类型的键映射到 V 类型的值。与其他语言中的哈希、映射、对象等类似，哈希映射在通过键而非索引查找数据时非常有用，比如在游戏中记录各队得分，队名作为键，得分作为值。

一、哈希映射基础

1. 数据结构特性

  • 键唯一性：每个键只能存在一个对应值（值可以重复）
  • 无序存储：插入顺序不保留（迭代时输出顺序不确定）
  • 动态扩容：当元素数量超过容量时自动调整大小

2. 内存布局

  • 底层由数组 + 链表实现（开放寻址法或分离链接法）
  • 每个桶（bucket）存储哈希冲突的键值对
  • 负载因子（load factor）控制扩容阈值（默认0.75）

二、创建与初始化

1. 基本创建方式

rust 复制代码 
use std::collections::HashMap;

// 方式1：显式类型标注
let mut scores: HashMap<&str, i32> = HashMap::new();
scores.insert("Blue", 10);

// 方式2：类型推断
let mut scores = HashMap::with_capacity(2); // 预分配空间
scores.insert(String::from("Blue"), 10);

2. 从其他结构转换

rust 复制代码 
let teams = [("Red", 30), ("Green", 40)];
let scores: HashMap<_, _> = teams.iter().cloned().collect();

三、值访问与修改

1. 安全访问

rust 复制代码 
// 安全获取值（处理None情况）
let score = scores.get("Blue").copied().unwrap_or_default();

// 链式调用示例
let score = scores.get("Blue").map_or(0, |&s| s + 5);

2. 遍历方式

rust 复制代码 
// 不可变遍历
for (key, value) in &scores {
    println!("{}: {}", key, value);
}

// 可变遍历
for (key, value) in &mut scores {
    *value *= 2;
}

四、所有权与引用

1. 键值所有权规则

rust 复制代码 
// 插入所有权值（键和值都被移动）
let key = String::from("Blue");
let value = 10;
scores.insert(key, value);
// key和value在此处失效

// 插入引用（需要确保引用有效性）
let key = "Blue";
let value = 10;
scores.insert(key, value);
// key和value仍然有效

2. 生命周期示例

rust 复制代码 
fn main() {
    let mut map = HashMap::new();
    let key = String::from("Blue");
    
    {
        let value = 10;
        map.insert(&key, value); // value在此块结束后失效
    } // 这里会报错：map中的引用指向已释放的value
}

五、高级更新操作

1. Entry API详解

rust 复制代码 
// 使用Entry的不同方法
let count = map.entry("hello")
    .or_insert(0); // 不存在则插入0，返回&mut i32
*count += 1;

// 更复杂的更新逻辑
map.entry("world")
    .and_modify(|e| *e += 1) // 存在则修改
    .or_insert(1); // 不存在则插入1

2. 批量更新示例

rust 复制代码 
let words = ["hello", "world", "hello"];
let mut map = HashMap::new();

for word in words {
    map.entry(word)
        .or_insert(0)
        .checked_add(1) // 防止溢出
        .expect("Overflow");
}

六、哈希函数与性能优化

1. 默认哈希算法

  • SipHash-2-4（12字节密钥）
  • 特点：抗哈希碰撞攻击，适合安全敏感场景
  • 性能：在x86-64架构下约1.5 cycles/byte

2. 自定义哈希器

rust 复制代码 
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

struct CustomHasher {
    state: DefaultHasher,
}

impl CustomHasher {
    fn new() -> Self {
        CustomHasher { state: DefaultHasher::new() }
    }
}

impl BuildHasher for CustomHasher {
    type Hasher = DefaultHasher;
    
    fn build_hasher(&self) -> Self::Hasher {
        self.state.clone()
    }
}

// 使用自定义哈希器创建HashMap
let mut map = HashMap::with_hasher(CustomHasher::new());

七、实际应用模式

1. 统计频率

rust 复制代码 
let text = "hello world wonderful world";
let mut counts = HashMap::new();

for word in text.split_whitespace() {
    counts.entry(word)
        .and_modify(|cnt| *cnt += 1)
        .or_insert(1);
}

2. 配置存储

rust 复制代码 
use std::env;

let mut config = HashMap::new();
for (key, value) in env::vars() {
    if key.starts_with("APP_") {
        config.insert(key, value);
    }
}

八、性能注意事项

  1. 预分配空间：使用with_capacity()减少扩容次数
  2. 哈希冲突处理：选择合适的哈希函数和负载因子
  3. 迭代优化：优先使用for循环而非iter()方法
  4. 内存局部性：键值对类型应具有良好的缓存友好性

九、常见错误处理

  1. 并发访问：使用std::sync::HashMap处理多线程场景
  2. 空值处理：始终检查get()返回的Option
  3. 生命周期问题：确保引用存活期覆盖哈希表使用期

十、扩展阅读