集合

为了创建一个新的空 vector，可以调用 Vec::new 函数，如下所示：

let v: Vec<i32> = Vec::new();

注意：这里增加了一个 类型 注解。因为没有向这个 vector 中插入任何值，Rust 并不知道想要储存什么类型的元素

     这是一个非常重要的点：vector 是用泛型实现的，它可以存放任何类型

     而当 Vec 存放某个特定类型时，那个类型位于尖括号中

     在示例中，v 这个 Vec 将存放 i32 类型的元素

在更实际的代码中，一旦插入值 Rust 就可以推断出想要存放的类型，所以你很少会需要这些类型注解。更常见的做法是使用 初始值 来创建一个 Vec，而且为了方便 Rust 提供了 vec! 宏。这个宏会根据 提供的值 来创建一个新的 Vec。下面新建一个拥有值 1、2 和 3 的 Vec<i32>：

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

因为提供了 i32 类型的初始值，Rust 可以推断出 v 的类型是 Vec<i32> ，因此类型注解就不是必须的。接下来让看看如何修改一个 vector

对于新建一个 vector 并向其增加元素，可以使用 push 方法：

let mut v = Vec::new();

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

• 如果想要能够改变它的值，必须使用 mut 关键字使其可变
• 放入其中的所有值都是 i32 类型的，而且 Rust 也根据数据做出如此判断，所以不需要 Vec<i32> 注解

     另外除了 push 之外还有一个 pop 方法，它会移除并返回 vector 的最后一个元素

类似于任何其他的 struct，vector 在其 离开作用域时会被释放 ，如下面注释：

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

    // 处理变量 v

} // <- 这里 v 离开作用域并被丢弃

     当 vector 被丢弃时，所有其内容也会被丢弃，这意味着这里它包含的整数将被清理

     这可能看起来非常直观，不过一旦开始使用 vector 元素的引用，情况就变得有些复杂了

访问 vector 中一个值的两种方式， 索引 语法或者 get 方法：

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

let third: &i32 = &v[2];
println!("The third element is {}", third);

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

这里有两个需要注意的地方：

• 使用 索引值 2 来获取 第三个 元素，索引是从 0 开始的
• 两个不同的获取第三个元素的方式分别为：
  • 使用 & 和 [] 返回一个 引用
  • 使用 get 方法以索引作为参数来返回一个 Option<&T>

Rust 有两个引用元素的方法的原因：程序可以选择如何处理当索引值在 vector 中没有对应值的情况

如果有一个有五个元素的 vector 接着尝试访问索引为 100 的元素时程序会如何处理，如下所示：

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

let does_not_exist = &v[100];
let does_not_exist = v.get(100);

当运行这段代码，对于第一个 [] 方法，当引用一个不存在的元素时 Rust 会 造成 panic

     这个方法更适合当程序认为尝试访问超过 vector 结尾的元素是一个严重错误的情况，这时应该使程序崩溃

当 get 方法被传递了一个数组外的索引时，它不会 panic 而是 返回 None

     当偶尔出现超过 vector 范围的访问属于正常情况的时候可以考虑使用它，接着代码可以有处理 Some(&element) 或 None 的逻辑

     例如 索引可能来源于用户输入的数字。如果它们不慎输入了一个过大的数字那么程序就会得到 None 值，可以告诉用户当前 vector 元素的数量并再请求它们输入一个有效的值

     这就比因为输入错误而使程序崩溃要友好的多！

一旦程序获取了一个有效的引用，借用检查器将会执行 所有权 和 借用规则 来确保 vector 内容的这个引用和任何其他引用保持有效。当获取了 vector 的 第一个元素的不可变引用 并尝试在 vector 末尾增加一个元素 的时候，这是行不通的：

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

let first = &v[0];

v.push(6);

println!("The first element is: {}", first);

这时候会有编译报错：

error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:7:5
  |
5 |     let first = &v[0];
  |                  - immutable borrow occurs here
6 |
7 |     v.push(6);
  |     ^^^^^^^^^ mutable borrow occurs here
8 |
9 |     println!("The first element is: {}", first);
  |                                          ----- immutable borrow later used here

     不能这么做的原因是由于 vector 的工作方式：

     在 vector 的结尾增加新元素时，在没有足够空间将所有所有元素依次相邻存放的情况下，可能会要求分配新内存并将老的元素拷贝到新的空间中

     这时，第一个元素的引用就指向了被释放的内存

     借用规则阻止程序陷入这种状况

如果想要依次访问 vector 中的每一个元素，可以遍历其所有的元素而无需通过索引一次一个的访问。下面展示了如何使用 for 循环来获取 i32 值的 vector 中的每一个元素的 不可变引用 并将其打印：

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

也可以遍历可变 vector 的每一个元素的 可变引用 以便能改变他们。下面的 for 循环会给每一个元素加 50：

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

vector 只能储存相同类型的值。这是很不方便的；绝对会有需要储存一系列不同类型的值的用例

幸运的是， 枚举 的成员都被定义为相同的枚举类型，所以当需要在 vector 中储存不同类型值时，可以定义并使用一个枚举

假如想要从电子表格的一行中获取值，而这一行的有些列包含数字，有些包含浮点值，还有些是字符串

1. 可以定义一个枚举，其成员会存放这些不同类型的值，同时所有这些枚举成员都会被当作相同类型，那个枚举的类型

2. 接着可以创建一个储存枚举值的 vector，这样最终就能够储存不同类型的值了

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

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

Rust 在编译时就必须准确的知道 vector 中类型的原因：

1. 它需要知道 储存每个元素 到底 需要多少内存
2. 可以准确的知道这个 vector 中 允许什么类型
   • 如果 Rust 允许 vector 存放任意类型，那么当对 vector 元素执行操作时一个或多个类型的值就有可能会造成错误
   • 用枚举外加 match 意味着 Rust 能在编译时就保证总是会处理所有可能的情况

     如果在编写程序时不能确切无遗地知道运行时会储存进 vector 的所有类型，枚举技术就行不通了。相反，可以使用 trait 对象

Rust 的核心语言中只有一种字符串类型： str ，而 字符串 slice 通常以被 借用 的形式出现 &str

     字符串 slice 是一些储存在别处的 UTF-8 编码字符串数据的引用。比如：字符串字面值被储存在程序的二进制输出中

称作 String 的类型是由 标准库 提供的，而没有写进核心语言部分，它是 可增长的 、 可变的 、 有 所有权的 、 UTF-8 编码的字符串类型

     当 Rustacean 们谈到 Rust 的 “字符串”时，它们通常指的是 String 和字符串 slice &str 类型，而不仅仅是其中之一

     虽然本部分内容大多是关于 String 的，不过这两个类型在 Rust 标准库中都被广泛使用，String 和字符串 slice 都是 UTF-8 编码的

Rust 标准库中还包含一系列其他字符串类型，比如 OsString、OsStr、CString 和 CStr，相关库 crate 甚至会提供更多储存字符串数据的选择

看到这些由 String 或是 Str 结尾的名字了吗？这对应着它们提供的所有权和可借用的字符串变体，就像是你之前看到的 String 和 str

举例而言，这些字符串类型能够以不同的编码，或者内存表现形式上以不同的形式，来存储文本内容

很多 Vec 可用的操作在 String 中同样可用，从以 new 函数创建字符串开始，如下所示：

let mut s = String::new();

这新建了一个叫做 s 的空的字符串，接着可以向其中装载数据

     通常字符串会有初始数据，因为希望一开始就有这个字符串

可以使用 to_string 方法，它能用于任何实现了 Display trait 的类型， 字符串字面值 也实现了它：

let data = "initial contents";

let s = data.to_string();

// 该方法也可直接用于字符串字面值：
let s = "initial contents".to_string();

也可以使用 String::from 函数来从字符串字面值创建 String。下面的代码等同于使用 to_string :

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

     因为字符串应用广泛，这里有很多不同的用于字符串的通用 API 可供选择

     其中一些可能看起来多余，不过都有其用武之地！

     在这个例子中，String::from 和 .to_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("Olá");
let hello = String::from("Здравствуйте");
let hello = String::from("Hola");

所有这些都是有效的 String 值

String 的 大小 可以增加，其 内容 也可以改变，就像可以放入更多数据来改变 Vec 的内容一样。另外，可以方便的使用 + 运算符 或 format! 宏 来拼接 String 值

在很多语言中，通过 索引 来引用字符串中的单独字符是有效且常见的操作。然而在 Rust 中，如果尝试使用索引语法访问 String 的一部分，会出现一个错误：

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

这会产生下面的编译错误：

error[E0277]: the type `std::string::String` cannot be indexed by `{integer}`
 --> src/main.rs:3:13
  |
3 |     let h = s1[0];
  |             ^^^^^ `std::string::String` cannot be indexed by `{integer}`
  |
  = help: the trait `std::ops::Index<{integer}>` is not implemented for `std::string::String`

错误和提示说明了全部问题：Rust 的字符串不支持索引

     那么接下来的问题是，为什么不支持呢？

     为了回答这个问题，必须先聊一聊 Rust 是如何在内存中储存字符串的

   幸运的是，这里还有其他获取字符串元素的方式

如果需要操作单独的 Unicode 标量值，最好的选择是使用 chars 方法。对 “नमस्ते” 调用 chars 方法会将其分开并返回六个 char 类型的值，接着就可以遍历其结果来访问每一个元素了：

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

这会打印出如下内容：

 न
 म
 स
 ्
 त
 े

另外 bytes 方法返回每一个原始字节：

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

这会打印出：

224
164
// --snip--
165
135

注意：有效的 Unicode 标量值可能会由不止一个字节组成

     从字符串中获取字形簇是很复杂的，所以标准库并没有提供这个功能

Rust 选择了以 准确 的方式处理 String 数据作为所有 Rust 程序的默认行为，这意味着程序员们必须更多的思考如何预先处理 UTF-8 数据

不同的语言选择了不同的向程序员展示其复杂性的方式

Rust 相比其他语言更多的暴露出了字符串的复杂性，不过也使在开发生命周期后期免于处理涉及非 ASCII 字符的错误

可以使用 new 创建一个空的 HashMap，并使用 insert 增加元素：

   例如：记录两支队伍的分数，分别是蓝队和黄队。蓝队开始有 10 分而黄队开始有 50 分：

use std::collections::HashMap;

let mut scores = HashMap::new();

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

注意：

• 必须使用 use 导入标准库中集合部分的 HashMap

  在这三个常用集合中，HashMap 是最不常用的，所以并没有被 prelude 自动引用

  标准库中对 HashMap 的支持也相对较少，例如，并没有内建的构建宏

• 像 vector 一样，哈希 map 将它们的 数据储存在堆 上，这个 HashMap 的键类型是 String 而值类型是 i32
  • 类似于 vector，哈希 map 是 同质 的：所有的键必须是相同类型，值也必须都是相同类型

另一个构建哈希 map 的方法是使用一个元组的 vector 的 collect 方法，其中每个元组包含一个 键值对 :

  例如，如果队伍的名字和初始分数分别在两个 vector 中，可以使用 collect 方法将这个元组 vector 转换成一个 HashMap

代码如下所示：

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

• zip 方法： 创建一个元组的 vector ，比如“蓝队”和“10”
• collect 方法：可以将数据收集进一系列的集合类型，包括 HashMap

HashMap<_, _> 类型注解是必要的，因为可能 collect 很多不同的数据结构，而除非显式指定否则 Rust 无从得知你需要的类型

但是对于键和值的类型参数来说，可以使用下划线占位，而 Rust 能够根据 vector 中数据的类型推断出 HashMap 所包含的类型

• 对于像 i32 这样的实现了 Copy trait 的类型，其值可以 拷贝 进哈希 map
• 对于像 String 这样拥有所有权的值，其值将被 移动 而哈希 map 会成为 这些值的所有者

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);
// 这里 field_name 和 field_value 不再有效，
// 尝试使用它们看看会出现什么编译错误！

当 insert 调用将 field_name 和 field_value 移动到哈希 map 中后，将不能使用这两个绑定

如果将 值的引用 插入哈希 map，这些值本身将不会被移动进哈希 map。但是这些引用指向的值必须至少在哈希 map 有效时也是有效的

可以通过 get 方法并提供对应的键来从哈希 map 中获取值：

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> ：如果某个键在哈希 map 中没有对应的值，get 会返回 None

   这里，score 是与蓝队分数相关的值，应为 Some(10)

可以使用与 vector 类似的方式来 遍历 哈希 map 中的每一个键值对，也就是 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);
}

这会以任意顺序打印出每一个键值对：

Yellow: 50
Blue: 10

尽管键值对的数量是可以增长的，不过 任何时候，每个键只能关联一个值 。当想要改变哈希 map 中的数据时，必须决定如何处理一个键已经有值了的情况。可以选择：

1. 完全无视旧值并用新值代替旧值
2. 可以选择保留旧值而忽略新值，并只在键 没有 对应值时增加新值
3. 可以结合新旧两值

HashMap 默认使用一种 “密码学安全的” 1 哈希函数，它可以抵抗拒绝服务攻击

然而这并不是可用的最快的算法，不过为了更高的安全性值得付出一些性能的代价

如果性能监测显示此哈希函数非常慢，以致于无法接受，可以指定一个不同的 hasher 来切换为其它函数，hasher 是一个实现了 BuildHasher trait 的类型

并不需要从头开始实现你自己的 hasher；crates.io 有其他人分享的实现了许多常用哈希算法的 hasher 的库