Rust 编程语言的标准函数库中已有内置了数个好用的集合数据结构。不同于基本数据类型只能够保存一个值,也不同于元组、数组、结构体只能保存固定大小的数据量,集合的数据结构将数据保存在堆积中,也就是说不需要在编译阶段就知道要存入的数据的数量和大小。

每一种集合数据结构有着不同的性能,我们必须看情况自行选择一个适当的来使用。在这个章节中,我们会介绍三种 Rust 编程语言内置的集合:Vec、String 和 HashMap。

Vec

Vec 为利用矢量(Vector)式数据结构所实作出来的结构体,可以将多个同一种类型的数据保存在一块连续的内存上,类似数组。但与数组不同的是,这块连续的内存空间大小是可以变动的,所以可以保存不固定数量的元素。

创建新的 Vec 结构实体

使用 Vec 结构体所提供的 new 函数,可以创建出 Vec 结构实体。Vec 结构体已经包含在 std::prelude 中,因此不用再特别使用其它命名空间。有一点要注意的是,虽然我们还没有开始正式学习泛型,但 Rust 编程语言的集合类型通常会搭配泛型一起使用。Vec 的泛型定义为 <T>,只有一个参数。如果我们直接将代码写成以下这样,会编译错误:

let v = Vec::new();

编译错误的原因是,编译器并不知道 Vec 的泛型 T 实际上到底是什么东西。我们需要定义清楚,才能够让程序通过编译。程序如下:

let v1: Vec<i32> = Vec::new();
let v2 = Vec::<i32>::new();

以上使用了两种不同的方式来实体化 Vec 结构体。第一种,透过直接定义 v1 变量的类型来指定 Vec 的泛型 T 的类型,再指派 Vec 结构实体给它。第二种,利用「turbofish」语法直接给定泛型 T 的类型。

由于 Vec 结构体在 Rust 编程语言中实在是太常用了,如果每次要创建 Vec 结构实体的时候都必须要将代码写成以上这样实在是很麻烦,所以 Rust 有另外提供了语法糖来创建 Vec 结构实体。程序如下:

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

看到 vec! 结尾的惊叹号就知道它跟 println! 一样是个宏。直接在 vec! 后面接上数组的语法,就可以产生出 Vec 结构实体并赋予它要保存的初始元素。

将数据存入 Vec 结构实体

使用 Vec 结构实体提供的 push 方法,可以将新的数据插入至该 Vec 结构实体的尾端。举例来说:

fn main() {
    let mut v = Vec::new();

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

以上程序利用 Vec 结构实体提供的 push 方法,将值 5、6、7、8 存入 Vec 结构实体中,Vec 结构实体会自动增加其使用的内存空间以存放这些值。这里要注意的是,第 2 行创建出 Vec 结构实体时,并没有去指定泛型 T 的类型,但程序却依然能通过编译。这个状况跟之前提到的在使用 let 关键字时明确定义 Vec 类型的方式有点类似,只不过我们现在是将明确定义 Vec 类型的地方放在第一次使用这个 Vec 结构实体时。

读写 Vec 结构实体中的元素

Vec 结构实体的用法和数组的用法几乎一样。举例来说:

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

以上程序,将 Vec 结构实体 v 索引 2 的 3 存到索引 0 的位置,取代掉原本索引 0 的 1。

当然,Vec 结构实体也可以跟数组一样,使用 get 方法来取得元素值。程序如下:

let mut v = vec![1, 2, 3, 4];
let x = v.get(0);

get 方法所回传的值为 Option 枚举的实体,如果传入 get 方法的索引值在 Vec 结构实体的索引范围内的话,就会回传 Some 变体的实体,且包裹元素值的参考在第一个参数;如果索引值超出范围,就会回传 None 变体的实体。

使用 For 循环走访的方式也跟数组一样。程序如下:

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

for i in &v {
    println!("{i}");
}

Vec 结构体的使用方式就是这么简单,跟数组非常相似。除了有可以将新元素插入至 Vec 结构实体尾端的 push 方法之外,另外还有 pop 方法可以移除 Vec 结构实体尾端的元素并回传出来。例如:

let mut v = vec![1, 2];

let two = v.pop();

就连切片的用法也和数组完全相同,包括切片的类型也是一样。例如:

fn main() {
    let mut a = vec![1, 2, 3, 4, 5];

    print_array(&a);
    fill_array(&mut a[2..4], 0);
    print_array(&a);
}

fn print_array(arr: &[i32]) {
    println!("{arr:?}");
}

fn fill_array(arr: &mut [i32], value: i32) {
    for i in arr.iter_mut() { // or for i in arr
        *i = value;
    }
}

我们先前使用过的 String 结构体其实也是使用 Vec 结构体来实作的,因此可以改变字符串的长度。底下就来深入探讨 Rust 编程语言的字符串究竟是如何运作的。

String

什么是字符串?

首先我们来确定一下「字符串」的意义。

Rust 编程语言原生的字符串类型为 str,我们会以它的切片类型来使用它,也就是 &str。直接写在 Rust 编程语言的字符串定数,类型就是 &str。&str 就是一个参考,指到内存中某个存放着 UTF-8 编码的字符串数据的区块,且是不可变的。

Rust 编程语言的标准函数库提供 String 结构体,且这个 String 结构体被涵盖在 std::prelude 中,使用时不需要特别指定命名空间。String 结构体所表示的字符串,可改变、可增长,同样也是使用 UTF-8 编码,因此 &String 也可以自动转型为 &str。

当我们提到 Rust 的「字符串」时,通常就是在讲 &str 和 String 这两个类型,而不光只讲其中一个。

除了刚才提到的 str 和 String 这两个类型之外,Rust 编程语言的标准函数库还提供了 OsString/OsStr、CString/CStr 等等用不同实作方式来处理字符串的结构体,命名方式就是 *String/*Str(星号 * 代表任意名称)。它们可能就会以别种格式编码字符串数据,或是用别的数据结构来保存字符串数据。

创建新字符串

如果我们要创建出来的字符串在之后需要进行改变的话,就使用 String 结构体。String 结构体提供了 new 函数可以快速地创建出一个代表空字符串的 String 结构实体。程序如下:

let mut s = String::new();

如果要让创建出来的 String 结构体拥有非空字符串的初始值的话,可以使用 from 函数。程序如下:

let mut s = String::from("initial contents");

甚至也可以直接使用字符串切片 &str 的 to_string 方法,来借由字符串切片产生出 String 结构实体。程序如下:

let s = "initial contents";
let mut s = (&s[..7]).to_string();

Rust 的字符串(&str、String)是用 UTF-8 来进行编码,不太需要担心会有什么字符无法支持。举例来说:

let hello = String::from("السلام عليكم");
let hello = String::from("Dobrý den");
let hello = String::from("Hello");
let hello = String::from("שָׁלוֹם");
let hello = String::from("नमस्ते");
let hello = String::from("こんにちは");
let hello = String::from("안녕하세요");
let hello = String::from("你好");
let hello = String::from("Olá");
let hello = String::from("Здравствуйте");
let hello = String::from("Hola");
let hello = String::from("今日は");

以上用不同语言创建出来的「你好」字符串,都是可以正常使用和显示的。

串接字符串

我们可以使用 String 结构实体的 push_str 方法串接字符串,使原本的字符串变长。举例来说:

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

以上程序运行完 push_str 方法之后,s 变量所保存的字符串为 foobar。

另外还有 push 方法可以串接一个字符,使原本的字符串变长。举例来说:

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

以上程序运行完 push 方法之后,s 变量所保存的字符串为 lol。

+ 操作符被许多编程语言拿来做字符串串接的运算,Rust 也不例外,但 Rust 的 + 操作符有点不太一样。举例来说:

let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2; // Note that s1 has been moved here and can no longer be used

以上这段程序运行完之后,s3 变量即为 s1 变量保存的 String 结构实体,但所保存的字符串数据已经串接上 s2 变量的 world!,也就是说 s3 变量所保存的字符串为 Hello, world!。以上程序可以等效于:

let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let mut s_tmp = s1; // Note that s1 has been moved here and can no longer be used
s_tmp.push_str(&s2);
let s3 = s_tmp; // Note that s_tmp has been moved here and can no longer be used

因此在 + 操作符完成运算后,s1 变量的值实际上已经被「移动」给 s3 使用了。+ 操作符可以串接的字符串数量并没有限制,但是最一开始的操作数一定要是 String 结构实体。举例来说:

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

let s = s1 + "-" + s2 + "-" + s3;

以上程序可以成功编译,s 变量所保存的字符串为 tic-tac-toe。如果将以上程序改为:

let s1 = "tic";
let s2 = "tac";
let s3 = "toe";

let s = s1 + "-" + s2 + "-" + s3;

程序会编译失败,因为 + 操作符一开始的操作数并不是 String 结构实体。

Rust 编程语言的 + 操作符会沿用一开始作为操作数代入的 String 结构实体,并将之后要串接的字符串数据都保存到这个 String 结构实体中。这样的作法虽然让作为第一个操作数的变量被「移动」,但是可以省下重新创建一个新的 String 结构实体后,再把所有字符串数据拷贝进去的功夫。不过在某些情况下,我们还是需要持续使用串接前的 String 结构实体,这时可以考虑使用 format! 宏。

format! 宏的用法类似 println! 宏,只不过 println! 宏是直接把结果透过标准输出印在屏幕上,而 format! 宏则是将字符串的格式化结果回传出来。

举例来说:

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

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

使用 format! 宏来组合字符串就不会有「移动」的问题了,而且也不需要去在意目前串接的操作数到底是不是字符串切片。

字符串的索引值

之前的章节中,我们有提到字符串切片可以用来取得子字符串,但是切的索引范围必须刚好在 UTF-8 编码数据的字符与字符之间,否则程序会在运行阶段发生 panic。如果我们对 UTF-8 编码不是那么熟悉,不知道要怎么去算我们要抓的子字符串的索引范围,该怎么办呢?

Rust 的字符串提供了 chars 方法,可以将字符串转成 Chars 结构实体,其提供迭代器,可以一个一个准确地走访每个字符。举例来说:

for c in "中文ABC123".chars() {
    println!("{c}");
}

以上程序可以将每个字符依照从左到右的顺序,分别印在每一行。

如果我们想要利用索引值,来读取字符串中的第几个字符,比较方便的作法是将字符串转成 Vec 结构实体来访问。程序如下:

let char_vec: Vec<char> = "中文ABC123".chars().collect();

迭代器的 collect 方法可以将要走访的数据转成集合,我们在声明 char_vec 变量时明确定义变量的类型为 Vec<char>,因此 collect 方法会将数据转成 Vec<char> 的实体。泛型参数的类型部份也可以用底线 _ 取代,让编译器自行去推论泛型参数的类型。如此一来,char_vec[0] 就是字符 '中',char_vec[1] 就是字符 '文',char_vec[2] 就是字符 'A',依此类推。如果是用其它编程语言,可能是习惯把字符串转成字符数组,但因 Rust 编程语言的数组长度必须在编译阶段就决定好的关系,不能应付长度在编译阶段无法确定的字符串。当然,如果是字符串定数,大可直接把数组长度(字符串长度)人工算好后直接撰写在代码,但这样程序也会很难维护。

HashMap

HashMap 为利用哈希函数将一个「键值」(key)对应一个值的数据结构,其泛型的定义为 <K, V>。

创建新的 HashMap 结构实体并加入数据

使用 HashMap 结构体所提供的 new 函数,可以创建出 HashMap 结构实体。HashMap 结构体并未包含在 std::prelude 中,使用时需指定其命名空间,Rust 标准函数库的集合都在 std::collections 模块下。

举例来说:

use std::collections::HashMap;

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

以上程序,相当于用 HashMap 结构实体创建出一个计分表,蓝队 10 分,黄队 50 分。HashMap 结构实体的 insert 方法,可以将新的 key-value 数据加入进来,如果加入的键值已存在,就会覆盖原本保存的值。

刚才用过迭代器的 collect 方法,除了可以产生出 Vec 结构的实体外,也可以再配合 zip 方法来产生出 HashMap 结构的实体。

举例来说:

use std::collections::HashMap;

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

    let scores: HashMap<&String, &i32> = teams.iter().zip(initial_scores.iter()).collect();
}

泛型参数的类型部份也可以用底线 _ 取代,让编译器自行去推论泛型参数的类型。

取得 HashMap 结构实体中的数据

与 Vec 结构实体一样,使用 HashMap 结构实体提供的 get 方法可以透过键值来取得对应的值。举例来说:

use std::collections::HashMap;

fn main() {
    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 方法可以透过键值来取得对应的值,但如果我们需要利用取得的值来计算出新的值,覆盖掉原本保存的值,就要再次使用 insert 方法。HashMap 的键值可以是任何有实作 Eq 和 Hash 特性的型态的值,但这个值在作为 HashMap 的键值使用时必须要经过哈希函数算出哈希值,所以在使用键值查找数据时会消耗一些运算资源在计算哈希上。为了要让程序性能更好,我们应该要尽量地避免重复计算哈希值。

HashMap 结构实体有个 entry 方法,可以传入键值,直接回传键值对应的 key-value 数据,而不单单只是回传键值对应的值。也就是说,可以借由直接改变回传出来的 key-value 数据,来避免再次使用 HashMap 结构实体的 insert 方法。HashMap 结构实体的 entry 方法会回传一个 Entry 枚举的实体,利用其提供的 or_insert 方法,可以让它将值回传出来,如果值还没有被设置,就会设成传入 or_insert 方法第一个参数的值。

举例来说:

use std::collections::HashMap;

fn main() {
    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 world wonderful world 的单字数量。程序运行结果如下:

{"hello": 1, "world": 2, "wonderful": 1}

总结

Vec、字符串和 HashMap 都是很常被用来处理数据的类型,除了本章提到的用法外,Rust 编程语言的标准函数库还有很多品质好又方便的功能可以互相搭配使用,可以去翻阅一下 Rust 标准函数库的文档,看看能用它来做到多少事情吧!文档的网址如下:

下一章:错误处理。