异常教程

Rust 集合与字符串（长文解析）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

在编程领域，数据的存储与操作是构建应用程序的核心能力之一。Rust语言凭借其内存安全与高性能的特性，在系统编程与复杂项目开发中备受青睐。本文将聚焦 Rust 集合与字符串 的基础知识与实战技巧，通过案例与代码示例，帮助读者逐步掌握这一主题。无论是刚入门的开发者，还是希望深入理解Rust特性的中级工程师，都能从中获得实用价值。

一、集合类型：灵活管理数据的容器

1.1 Vec：动态数组的优雅实现

Vec 是 Rust 中最常用的集合类型之一，它提供了一个动态增长的数组结构。与固定长度的数组不同，Vec 的长度可在运行时动态调整，并自动管理内存。

核心特性：

  • 内存连续分配，适合高性能场景
  • 支持高效追加、插入与删除操作
  • 通过 push()、pop() 等方法实现增删

示例代码：

let mut vec_numbers = Vec::new();  
vec_numbers.push(10); // 添加元素  
vec_numbers.push(20);  

// 直接初始化  
let vec_letters = vec!['a', 'b', 'c'];  

// 访问元素  
if let Some(first) = vec_letters.first() {  
    println!("第一个元素是：{}", first);  
}

比喻：
可以把 Vec 想象成一个可伸缩的书架。当你需要放更多书时，它会自动扩展空间，但所有书籍（元素）始终按顺序排列，方便快速查找。

1.2 HashMap：键值对的高效存储

HashMap<K, V> 是 Rust 中实现键值对映射的核心类型。它通过哈希函数快速定位数据，适用于需要频繁查找、插入或删除键值对的场景。

核心特性：

  • 平均 O(1) 时间复杂度的查找与插入
  • 需要指定键与值的类型
  • 通过 entry API 处理键不存在的情况

示例代码：

use std::collections::HashMap;  

let mut scores = HashMap::new();  
scores.insert("Alice", 95);  
scores.insert("Bob", 88);  

// 获取值  
let alice_score = scores.get("Alice");  
if let Some(score) = alice_score {  
    println!("Alice 的分数是：{}", score);  
}

注意点：

  • 键类型必须实现 Eq 和 Hash trait
  • 如果键已存在，insert 会覆盖旧值

1.3 其他集合类型：BTreeMap 与 LinkedList

Rust 标准库还提供了其他集合类型，以适应不同场景的需求：

  • BTreeMap：基于 B-Tree 实现，保证键的有序性，适合需要按顺序遍历的场景。
  • LinkedList：双向链表结构，支持高效在头部或尾部插入/删除元素。

对比表格：
| 类型 | 特点 | 适用场景 |
|--------------|--------------------------|------------------------|
| HashMap | 无序，哈希索引 | 高频查找/插入 |
| BTreeMap | 键有序，按顺序遍历 | 需要有序访问的键值对 |
| LinkedList | 链式结构，支持两端操作 | 频繁在头部/尾部操作 |

二、字符串类型：从基础到高级操作

2.1 String 与 &str 的区别

Rust 中的字符串分为两种主要类型：

  • String：可变、拥有所有权的字符串类型，可动态修改内容。
  • &str：不可变的字符串切片，通常作为引用存在。

核心区别：
| 属性 | String | &str |
|--------------|---------------------------------|--------------------------|
| 所有权 | 拥有数据的所有权 | 仅持有引用 |
| 可变性 | 可修改内容（如追加字符） | 不可修改 |
| 内存分配 | 在堆上分配 | 可以是栈或堆的切片 |

示例代码：

let s1 = String::from("Hello"); // String 类型  
let s2 = "World"; // &str 类型  

// 转换为 String  
let s3 = s2.to_string();

2.2 字符串操作：遍历、拼接与切片

2.2.1 遍历字符

通过 chars() 方法可以逐字符遍历字符串：

let greeting = "你好，Rust！";  
for c in greeting.chars() {  
    println!("{}", c); // 输出每个字符  
}

2.2.2 拼接字符串

使用 + 运算符或 format! 宏拼接字符串：

let name = "Alice";  
let greeting = format!("Hello, {}!", name); // 推荐使用 format!

2.2.3 字符串切片

通过索引或 split_at() 方法获取子字符串：

let s = "Hello, Rust!";  
let substring = &s[7..11]; // "Rust"

注意：
字符串切片的索引必须是 UTF-8 编码的字符边界，否则会引发 panic。建议使用 chars() 或 char_indices() 避免越界问题。

2.3 所有权与字符串：避免常见陷阱

由于 Rust 的所有权机制，字符串操作需注意以下场景：

  1. 不可变借用与可变性：

    let s = String::from("text");  
let first_char = &s[0..1]; // 允许不可变借用  
s.push_str(" more"); // 此时 s 被可变借用，会引发错误

    解决方法：确保在借用期间不修改字符串。

  2. 跨生命周期引用：
    当函数返回字符串切片时，需确保其生命周期与原始字符串一致：

    fn get_prefix(s: &str) -> &str {  
    &s[0..3] // 正确，返回的引用依赖于输入参数的生命周期  
}

三、实战案例：统计文本单词频率

3.1 需求分析

假设需要统计一段文本中每个单词的出现频率。例如输入："Rust is great, Rust is fun!"，输出：

Rust: 2  
is: 2  
great: 1  
fun: 1

3.2 实现步骤

  1. 分割字符串为单词列表
    使用 split_whitespace() 或正则表达式分割文本。
  2. 使用 HashMap 统计频率
    遍历单词列表，用键值对记录出现次数。

完整代码：

use std::collections::HashMap;  

fn count_words(text: &str) -> HashMap<String, usize> {  
    let mut counts = HashMap::new();  
    for word in text.split_whitespace() {  
        let normalized = word.to_lowercase(); // 统一为小写  
        *counts.entry(normalized).or_insert(0) += 1;  
    }  
    counts  
}  

fn main() {  
    let text = "Rust is great, Rust is fun!";  
    let result = count_words(text);  
    for (word, count) in &result {  
        println!("{}: {}", word, count);  
    }  
}

3.3 代码解析

  • split_whitespace()：按空格分割字符串，忽略标点符号（需进一步优化）。
  • entry API：通过 or_insert 处理键是否存在的情况，简化代码逻辑。

四、进阶技巧：迭代器与模式匹配

4.1 迭代器优化数据处理

Rust 的迭代器链能以简洁的方式处理集合数据。例如，统计单词长度超过 4 的单词数量：

let words = vec!["apple", "Rust", "language", "fun"];  
let count = words.iter()  
    .filter(|&w| w.len() > 4)  
    .count();  
println!("符合条件的单词数量：{}", count); // 输出 2

4.2 模式匹配处理集合元素

结合 match 或 if let 可更灵活地操作集合：

let mut scores = HashMap::new();  
scores.insert("Alice", vec![90, 85]);  

match scores.get("Alice") {  
    Some(grades) => println!("平均分：{}", grades.iter().sum::<i32>() / grades.len() as i32),  
    None => println!("无成绩"),  
}

五、性能与内存优化

5.1 Vec 的容量预分配

频繁调用 push 时，可通过 with_capacity 预分配内存，减少重新分配的开销：

let mut vec = Vec::with_capacity(100); // 预留 100 个元素空间  
for i in 0..100 {  
    vec.push(i); // 避免多次扩容  
}

5.2 字符串的堆分配优化

避免不必要的 to_string() 调用，优先使用切片：

// 低效写法  
let s = "Hello".to_string() + " World"; // 两次堆分配  

// 高效写法  
let s = format!("Hello World"); // 单次分配

结论

通过本文，我们系统梳理了 Rust 集合与字符串 的核心概念与实践方法。从 Vec 的动态数组特性到 HashMap 的高效键值存储，再到字符串的所有权管理，Rust 的内存安全机制始终贯穿其中。结合实战案例与进阶技巧，开发者可以更自信地处理复杂的数据结构问题。

掌握这些知识后，建议继续探索 Rust 的高级主题，如并发集合（如 Mutex<Vec>）、自定义数据结构设计，以及通过 serde 库实现序列化/反序列化等。希望本文能成为您 Rust 学习旅程中的坚实基石！

最新发布

查看更多文章