Rust —— 常见集合

#Rust

Rust 标准库包含了一些非常实用的数据结构，称为集合（Collections）。与普通数据类型不同，集合可以包含多个值，数据存储在堆上，大小可以在运行时动态变化。

本文介绍三种最常用的集合：Vector、String 和 HashMap。

1. Vector（向量）

1.1 创建和更新 Vector

// 创建空 Vector
let v: Vec<i32> = Vec::new();

// 使用宏创建
let v = vec![1, 2, 3, 4, 5];

// 添加元素
let mut v = Vec::new();
v.push(5);
v.push(6);

1.2 读取元素

let v = vec![1, 2, 3, 4, 5];

// 方式1：索引（越界会 panic）
let third = &v[2];

// 方式2：get 方法（返回 Option）
match v.get(2) {
    Some(third) => println!("第三个元素是 {}", third),
    None => println!("没有第三个元素"),
}

1.3 遍历 Vector

let v = vec![100, 32, 57];

// 不可变遍历
for i in &v {
    println!("{}", i);
}

// 可变遍历
let mut v = vec![100, 32, 57];
for i in &mut v {
    *i += 50;
}

注意： 不能在持有 Vector 元素的不可变引用时修改 Vector。

1.4 存储多种类型

使用枚举在 Vector 中存储不同类型：

enum SpreadsheetCell {
    Int(i32),
    Float(f64),
    Text(String),
}

let row = vec![
    SpreadsheetCell::Int(3),
    SpreadsheetCell::Text(String::from("blue")),
    SpreadsheetCell::Float(10.12),
];

2. String（字符串）

2.1 创建 String

1
2
3

let s = String::from("hello");
let s = String::new();
let s = "initial contents".to_string();

2.2 更新 String

1
2
3

let mut s = String::from("foo");
s.push_str("bar");  // 追加字符串
s.push('!');        // 追加字符

2.3 拼接字符串

// 使用 + 运算符（会移动 s1）
let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2;

// 使用 format! 宏（推荐）
let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");
let s = format!("{}-{}-{}", s1, s2, s3);

2.4 索引字符串

Rust 不支持直接索引字符串：

1 2	let s1 = String::from("hello"); let h = s1[0]; // ❌ 错误！

原因： 字符串是 UTF-8 编码，一个字符可能占用多个字节。

2.5 遍历字符串

// 遍历字符
for c in "नमस्ते".chars() {
    println!("{}", c);
}

// 遍历字节
for b in "नमस्ते".bytes() {
    println!("{}", b);
}

3. HashMap（哈希映射）

3.1 创建 HashMap

use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

使用 collect 创建：

let teams = vec![String::from("Blue"), String::from("Yellow")];
let initial_scores = vec![10, 50];

let scores: HashMap<_, _> = teams.iter()
    .zip(initial_scores.iter())
    .collect();

3.2 访问值

let team_name = String::from("Blue");
match scores.get(&team_name) {
    Some(&s) => println!("分数: {}", s),
    None => println!("队伍不存在"),
}

3.3 遍历 HashMap

1
2
3

for (key, value) in &scores {
    println!("{}: {}", key, value);
}

注意： HashMap 是无序的。

3.4 更新 HashMap

// 覆盖值
scores.insert(String::from("Blue"), 25);

// 只在键不存在时插入
scores.entry(String::from("Yellow")).or_insert(50);

// 基于旧值更新
let text = "hello world wonderful world";
let mut map = HashMap::new();

for word in text.split_whitespace() {
    let count = map.entry(word).or_insert(0);
    *count += 1;
}

3.5 所有权

对于 String 等类型，插入 HashMap 后所有权会转移：

let field_name = String::from("Favorite color");
let field_value = String::from("Blue");

let mut map = HashMap::new();
map.insert(field_name, field_value);
// field_name 和 field_value 在此处无效

总结

Vector：动态数组，适合存储同类型的列表数据
String：UTF-8 编码的字符串，不支持索引但可遍历
HashMap：键值对存储，提供快速查找能力

掌握这三种集合的使用是编写 Rust 程序的基础。记住它们都存储在堆上，理解所有权规则对正确使用集合至关重要。

Hooray！常见集合学习完成！！！

#Rust