學習Rust 集合與字串

集合（Collection）是資料結構中最普遍的資料存放形式，Rust 標準庫中提供了豐富的集合型別幫助開發者處理資料結構的操作。

向量（Vector）是一個存放多值的單資料結構，該結構將相同型別的值線性的存放在記憶體中。
向量是線性表，在 Rust 中的表示是 Vec。
向量的使用方式類似於列表（List），我們可以透過這種方式建立指定型別的向量：

let vector: Vec= Vec::new(); // 建立型別為 i32 的空向量
let vector = vec![1, 2, 4, 8];     // 透過陣列建立向量

我們使用線性表常常會用到追加的操作，但是追加和棧的 push 操作本質是一樣的，所以向量只有 push 方法來追加單個元素：

例項

fn main() {
    let mut vector = vec![1, 2, 4, 8];
    vector.push(16);
    vector.push(32);
    vector.push(64);
    println!("{:?}", vector);
}

執行結果：

[1, 2, 4, 8, 16, 32, 64]

append 方法用於將一個向量拼接到另一個向量的尾部：

例項

fn main() {
    let mut v1: Vec= vec![1, 2, 4, 8];
    let mut v2: Vec= vec![16, 32, 64];
    v1.append(&mut v2);
    println!("{:?}", v1);
}

執行結果：

[1, 2, 4, 8, 16, 32, 64]

get 方法用於取出向量中的值：

例項

fn main() {
    let mut v = vec![1, 2, 4, 8];
    println!("{}", match v.get(0) {
        Some(value) => value.to_string(),
        None => "None".to_string()
    });
}

執行結果：

1

因為向量的長度無法從邏輯上推斷，get 方法無法保證一定取到值，所以 get 方法的返回值是 Option 列舉類，有可能為空。
這是一種安全的取值方法，但是書寫起來有些麻煩。如果你能夠保證取值的下標不會超出向量下標取值範圍，你也可以使用陣列取值語法：

例項

fn main() {
    let v = vec![1, 2, 4, 8];
    println!("{}", v[1]);
}

執行結果：

2

但如果我們嘗試獲取 v[4] ，那麼向量會返回錯誤。

遍歷向量：

例項

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

執行結果：

100
32
57

如果遍歷過程中需要更改變數的值：

例項

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

字串類（String）到本章為止已經使用了很多，所以有很多的方法已經被讀者熟知。本章主要介紹字串的方法和 UTF-8 性質。
新建字串：

let string = String::new();

基礎型別轉換成字串：

let one = 1.to_string();         // 整數到字串
let float = 1.3.to_string();     // 浮點數到字串
let slice = "slice".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("你好");
let hello = String::from("Olá");
let hello = String::from("Здравствуйте");
let hello = String::from("Hola");

字串追加：

let mut s = String::from("run");
s.push_str("oob"); // 追加字串切片
s.push('!');       // 追加字元

用 + 號拼接字串：

let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2;

這個語法也可以包含字串切片：

let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");
let s = s1 + "-" + &s2 + "-" + &s3;

使用 format! 宏：

let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");
let s = format!("{}-{}-{}", s1, s2, s3);

字串長度：

let s = "hello";
let len = s.len();
這裡 len 的值是 5。
let s = "你好";
let len = s.len();

這裡 len 的值是 6。因為中文是 UTF-8 編碼的，每個字元長 3 位元組，所以長度為6。但是 Rust 中支援 UTF-8 字元物件，所以如果想統計字元數量可以先取字串為字符集合：

let s = "hello你好";
let len = s.chars().count();

這裡 len 的值是 7，因為一共有 7 個字元。統計字元的速度比統計資料長度的速度慢得多。

遍歷字串：

例項

fn main() {
    let s = String::from("hello中文");
    for c in s.chars() {
        println!("{}", c);
    }
}

執行結果：

h
e
l
l
o
中
文

從字串中取單個字元：

例項

fn main() {
    let s = String::from("EN中文");
    let a = s.chars().nth(2);
    println!("{:?}", a);
}

執行結果：

Some('中')

注意：nth 函式是從迭代器中取出某值的方法，請不要在遍歷中這樣使用！因為 UTF-8 每個字元的長度不一定相等！

如果想擷取字串字串：
例項

fn main() {
    let s = String::from("EN中文");
    let sub = &s[0..2];
    println!("{}", sub);
}

執行結果：

EN

但是請注意此用法有可能肢解一個 UTF-8 字元！那樣會報錯：

例項

fn main() {
    let s = String::from("EN中文");
    let sub = &s[0..3];
    println!("{}", sub);
}

執行結果：

thread 'main' panicked at 'byte index 3 is not a char boundary; it is inside '中' (bytes 2..5) of `EN中文`', src\libcore\str\mod.rs:2069:5 
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

對映表（Map）在其他語言中廣泛存在。其中應用最普遍的就是鍵值雜湊對映表（Hash Map）。

新建一個雜湊值對映表：

例項

use std::collections::HashMap;
fn main() {
    let mut map = HashMap::new();
    map.insert("color", "red");
    map.insert("size", "10 m^2");
    println!("{}", map.get("color").unwrap());
}

注意：這裡沒有宣告雜湊表的泛型，是因為 Rust 的自動判斷型別機制。

執行結果：

red

insert 方法和 get 方法是對映表最常用的兩個方法。

對映表支援迭代器：

例項

use std::collections::HashMap;
fn main() {
    let mut map = HashMap::new();
    map.insert("color", "red");
    map.insert("size", "10 m^2");
    for p in map.iter() {
        println!("{:?}", p);
    }
}

執行結果：

("color", "red") 
("size", "10 m^2")

迭代元素是表示鍵值對的元組。

Rust 的對映表是十分方便的資料結構，當使用 insert 方法新增新的鍵值對的時候，如果已經存在相同的鍵，會直接覆蓋對應的值。如果你想"安全地插入"，就是在確認當前不存在某個鍵時才執行的插入動作，可以這樣：

map.entry("color").or_insert("red");

這句話的意思是如果沒有鍵為 "color" 的鍵值對就新增它並設定值為 "red"，否則將跳過。

在已經確定有某個鍵的情況下如果想直接修改對應的值，有更快的辦法：

例項

use std::collections::HashMap;
fn main() {
    let mut map = HashMap::new();
    map.insert(1, "a");
   
    if let Some(x) = map.get_mut(&1) {
        *x = "b";
    }
}