Rust 标准库包含了一系列被称为集合的数据结构。与内置的数组和元组不同，集合将自己持有的数据存储在堆上。这使得数据的大小不需要在编译时确定，且可以随着程序的运行按需扩大或缩小数据占用的空间。

Rust 中有 3 种最常用的集合类型：

• 动态数组（vector）
• 字符串（string）
• 哈希映射（hash map）

使用动态数组存储多个值

动态数组（Vec<T>）支持在单个数据结构中存储多个相同类型的值，这些值会彼此相邻地排布在内存中。

可以调用函数 Vec::new 来创建一个空的动态数组：
let v: Vec<i32> = Vec::new();

上述代码会创建一个用来存储 i32 数据地的空的动态数组。由于并未在这个动态数组中插入任何值，因此需要显式地添加类型标记（Vec<i32>）。

用初始值去创建动态数组的场景也十分常见，因此 Rust 特意提供了一个用于简化代码的 vec! 宏。
let v = vec![1, 2, 3]

更新动态数组：

let mut v = Vec::new();

v.push(5);
v.push(6);
v.push(7);
v.push(8);

销毁动态数组时也会销毁其中的元素

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

    //  执行与 v 相关的操作

} //  <- v 在这里离开作用域并随之被销毁

可以使用索引和 get 两种方法读取动态数组中的元素。

fn main() {
    let v = vec![1, 2, 3, 4];
    let third: &i32 = &v[2];
    println!("The third element is {}", third);

    match v.get(2) {
        Some(third) => println!("The third number is {}", third),
        None => println!("There is no third element"),
    }
}

需要注意的是：

• 动态数组使用数字进行索引，索引值从 0 开始
• 使用 & 与 [] 会直接返回元素的引用
• 接收索引作为参数的 get 方法会返回一个 Option<T> 类型

当尝试使用不存在的索引值去访问动态数组时，上述两种引用方法会导致程序触发不同的响应方式。比如对于某个持有 5 个元素的动态数组，尝试访问其索引为 100 的元素。

[] 方法会因为索引指向了不存在的元素而触发 panic，假如希望在尝试越界访问元素时令程序直接崩溃，此方法就很适用。
get 方法会在检测到索引越界时直接返回 None，而不会导致程序崩溃。当偶尔越界访问动态数组的元素是一种正常行为时，可以使用此方法。此外，代码应该合乎逻辑地处理 Some(&element) 与 None 两种不同的情形。

在存在指向动态数组元素的引用时，尝试向动态数组中添加元素会导致编译器报错。比如下面的代码：

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];
    let first = &v[0];
    v.push(6);
    print!("The first element is {}", first);
}

对第一个元素的引用需要关心动态数组结尾处的变化，这与动态数组的机制有关。
动态数组中的元素是连续地存储在堆中的，插入新的元素也许会没有足够多的空间将所有元素依次相邻地放下。这就需要分配新的内存空间，再将旧的元素移动到新的空间上，旧的空间被释放。
也就是说，动态数组末尾插入数据有可能导致上面代码中第一个元素的引用指向了被释放的内存。

遍历动态数组

fn main() {
    let v = vec![100, 32, 57];
    for i in &v {
        print!("{}", i);
    }
}

也可以遍历可变的动态数组，获得元素的可变引用，并修改其中的值。

fn main() {
    let mut v = vec![100, 32, 57];
    for i in &mut v {
        *i += 50;
        print!("{}", i)
    }
}

为了使 += 运算符修改可变引用的值，需要使用解引用运算符 * 来获取 i 绑定的值。

使用字符串存储 UTF-8 文本

Rust 在语言核心部分只有一种字符串类型，即字符串切片 str，通常以借用的形式（&str）出现。字符串切片是一些指向存储在别处的 UTF-8 编码的字符串的引用。

String 类型被定义在 Rust 标准库中，没有内置在语言的核心部分。它也采用了 UTF-8 编码。

创建字符串

许多对于 Vec<T> 的操作同样可用于 String，比如可以从 new 函数创建一个新的空字符串：
let mut s = String::new();

可以对那些实现了 Display trait 的类型调用 to_string 方法，创建有初始数据的字符串：
let s = "initial contents".to_string();

也可以使用 String::from 函数基于字符串字面量生成 String：
let s = String::from("initial contents");

字符串是基于 UTF-8 编码的，因此可以将任何合法的数据编码进字符串：
let hello = String::from("你好");

更新字符串

可以使用 push_str 方法来向 String 中添加一段字符串切片。

let mut s = String::from("foo");
s.push_str("bar");

push 方法接收单个字符作为参数，并将它添加到 String 中。

let mut s = String::from("lo");
s.push('l');

使用 + 运算符将两个 String 合并到一个新的 String 中：

fn main() {
    let s1 = String::from("Hello, ");
    let s2 = String::from("world!");
    let s3 = s1 + &s2;  // 这里的 s1 已经被移动且再也不能被使用
    println!("{}", s3);
}

需要注意的是，上面的加法操作中只对变量 s2 采用了引用，而 s1 由于所有权的移动在加法操作之后不再有效。
这里的 + 运算符会调用一个 add 方法，其签名类似于：
fn add(self, s: &str) -> String {

由于函数签名中的 self 并没有使用 & 标记，因此 add 函数会取得 self 的所有权，导致 s1 被移动至 add 函数调用中，在调用后失效。
这种实现要比单纯的复制更加高效。

对于复杂一些的比如多个字符串的合并，可以使用 format! 宏：

let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");

let s = format!("{}-{}-{}", s1, s2, s3);

format! 宏与 println! 宏的工作原理完全相同，只不过 format! 会将结果包含在一个 String 中返回。这使得用 format! 的代码更加易读，且不会夺取任何参数的所有权。

字符串索引

Rust 中的字符串不支持索引。比如下面的代码会导致编译器报错：

let s1 = String::from("hello");
let h = s1[0];

String 实际上是一个基于 Vec<u8> 的封装类型。
let len = String::from("Hola").len(); 中，变量 len 的值为 4，意味着动态数组所存储的字符串 Hola 占用了 4 个字节。
而 let len = String::from("你好").len(); 中，Rust 返回的结果却并不是 2，而是 6。这就是使用 UTF-8 编码来存储“你好”所需要的字节数。
因此对于字符串中字节的索引并不总是能对应到一个有效的 Unicode 标量值。

还有一个原因，索引操作的复杂度往往会被预期为常数时间 O(1)，但在 String 中，Rust 必须要从头遍历至索引位置来确定究竟有多少合法字符存在，这无法保障常数时间的性能。

字符串切片

字符串切片是指向 String 对象中某个连续部分的引用：

let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];

向函数传入字符串切片并不会导致切片指向的原始 String 因为所有权的移动而失效。

字符串字面量就是切片。
let s = "Hello, world!";
变量 s 的类型其实是 &str，是一个指向二进制程序特定位置的切片。正是由于 &str 是一个不可变引用，字符串字面量才是不可变的。

尝试通过索引引用字符串通常是一个坏主意，因为该操作应当返回的类型是不明确的：究竟应该是字节、字符、字形簇还是切片呢？
Rust 要求程序员做出更加明确的标记，在索引的 [] 中填写范围来指定所需的字节内容，即明确其类型为字符串切片。

fn main() {
    let hello = String::from("你好");
    let s = &hello[0..3];
    println!("{}", s);
    // => 你
}

在上面的代码中，s 将会是一个包含了字符串前 3 个字节的 &str，即 你。若尝试在代码中使用 &hello[0..2]，则程序运行时会发生 panic：
thread 'main' panicked at 'byte index 2 is not a char boundary; it is inside '你' (bytes 0..3) of `你好`'

切记要小心谨慎地使用范围语法创建字符串切片。

假如确实需要对每一个 Unicode 标量值都进行处理，最好的办法是使用 chars 方法：

fn main() {
    let hello = String::from("你好");
    for c in hello.chars() {
        println!("{}", c);
        // => 你
        // => 好
    }
}

在映射中存储键值对

哈希映射 HashMap<K, V> 存储了从 K 类型键关联到 V 类型值之间的映射关系。

创建哈希映射

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

和动态数组一样，哈希映射也将其数据存储在堆上。它同样也是同质的，即所有键必须拥有相同的类型，所有的值也必须拥有相同的类型。

另一种构建哈希映射的方法：

use std::collections::HashMap;

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();

哈希映射与所有权

对于那些实现了 Copy trait 的类型如 i32，它们的值会被简单地复制到哈希映射中。而对于 String 这种持有所有权的值，其所有权会转移给哈希映射：

use std::collections::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);
// filed_name 和 field_value 从这一刻开始失效，若尝试使用它们则会导致编译错误！

在调用 insert 方法后，field_name 和 field_value 变量会被移动到哈希映射中，之后就无法再使用这两个变量了。

访问哈希映射中的值

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

let team_name = String::from("Blue");
let score = scores.get(&team_name);

get 返回的是一个 Option<&V> 类型。因此上面代码中的 score 将会是与蓝队相关联的值，即 Some(&10)。
若哈希映射中没有指定键所对应的值，get 方法就会返回 None。

可以使用 for 循环遍历哈希映射：

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

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

更新哈希映射

替换旧值

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Blue"), 25);

println!("{:?}", scores);

原来的值 10 会被新值 25 替换掉。

只在某个键没有对应值时才插入数据
即若某个键对应的值存在，保持原状；若该值不存在，将参数作为新值插入。

fn main() {
    use std::collections::HashMap;

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

    println!("{:?}", scores);
    // => {"Blue": 10, "Yellow": 50}
}

基于旧值更新值

fn main() {
    use std::collections::HashMap;

    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;
    }

    println!("{:?}", map);
    // => {"hello": 1, "world": 2, "wonderful": 1}
}

参考资料

The Rust Programming Language