对比学习 Go 和 Rust：集合类型

var _ [3]int                                            // 包含三个元素的数组，每个元素的值默认为 0
var _ [3]int = [3]int{}                                 // [3]int{} 字面量属于 [3]int 类型数组，所有元素为 0
var _ [3]int = *new([3]int)                             // 通过内建的 new 函数创建数组，该方法很少用
var _ [3]int = [3]int{1, 2, 3}                          // 包含三个元素的数组，给出了各个元素值
var _ [3]int = [3]int{1, 2}                             // 包含三个元素的数组，但只给出了前两个元素值
var _ [3]int = [3]int{0: 1, 2: 3, 1: 2}                 // 显式指定数组的 索引:值 对
var _ [3]int = [...]int{1, 2, 3}                        // 通过三个圆点 ... 让编译器自动计算元素个数
var _ [3]int = [...]int{2: 3}                           // 除了最后一个元素（索引为 2）的值是 3 外，其他元素都是 0
var _ [3]*int                                           // 数组的每个元素是一个指向整数值的指针，元素值默认为 nil
var _ *[3]int                                           // 定义了一个指向 [3]int 类型的数组的指针
var _ [2 * N]int                                        // 2 * N 必须是一个能转换为 int 的非负的常量表达式
var _ [2][2]int = [2][2]int{[2]int{1, 2}, [2]int{3, 4}} // [2]([2]int) ，相当于一个 2 维数组
var _ [2][2]int = [2][2]int{{1, 2}, {3, 4}}             // 以上二维数组值的简写形式
var _ [3][4][5]int                                      // [3]([4]([5]int))，该数组相当于一个 3 维数组
var _ [2]string = [2]string{"dog", "sheep"}             // 元素类型为 string 的数组

let _: [i32; 3];                         // 包含三个元素的数组，每个元素处于未初始化状态
let _: [i32; 3] = [1, 2, 3];             // 包含三个元素的数组，给出了各个元素值
let _: [i32; 3] = [1; 3];                // 快速将数组中所有元素的值指定为 1
let _: [&i32; 3];                        // 数组的每个元素是一个指向整数值的指针
let _: &[i32; 3];                        // 定义了一个指向 [i32; 3] 类型数组的指针
let _: [i32; 2 * N];                     // 2 * N 是一个常量表达式，其中 N 必须是一个 usize 类型的常量
let _: [[i32; 2]; 2] = [[1, 2], [3, 4]]; // 相当于一个二维数组
let _: [[[i32; 5]; 4]; 3];               // 相当于一个三维数组
let _: [&str; 2] = ["dog", "sheep"];     // 元素类型为 &str 的数组

// 先声明一个包含 10 个元素的数组 arr，用于后续的切分
var arr [10]int = [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

// 通过切分数组创建切片，数组索引从 3 到 5（6-1）变为切片元素，所得切片的长度为 3（6-3），容量为 7（10-3）
var _ []int = arr[3:6]
var a []int = arr[3:6:cap(arr)]                   // 通过指定底层数组的索引显式限定切片容量为 10-3，所得切片与上面相同
var _ []int = arr[:6]                             // 如果从 0 开始，若起始索引为 0，则可以省略
var _ []int = arr[3:]                             // 若终止索引为数组长度，则可以省略
var _ []int = arr[:]                              // 起始索引和终止索引可以同时省略，则切片引用整个数组
var _ []int = arr[:][3:6]                         // 可以对切片 arr[:] 进行再切分
var _ []int = make([]int, 10, 30)                 // 为数组 [30]int 分配内存，并从中切分前 10 各元素
var _ []int = (*new([30]int))[0:10]               // 该切片与上面的切片等价
var _ []int = new([30]int)[0:10]                  // 利用自动解引用特征，上一行代码可以进一步简化此行
var _ []int = make([]int, 10)                     // 用 make 创建切片时没有指定容量，则容量等于长度，即为 10
var _ []int                                       // 声明切片但没有赋值，则其默认为零值 nil
var _ []int = nil                                 // 当然也可以显式地指定切片的值为 nil，但没必要这样
var _ []int = []int(nil)                          // 更绕了，该切片的值还是 nil，实际没必要这样做
var _ []int = []int{1, 2, 3}                      // 这是切片的复合字面量，和数组类似，但不指定长度
var _ []int = []int{}                             // 注意这是一个长度和容量都为 0 的空切片，它不等于 nil
var _ []int = []int{0: 1, 2: 3, 1: 2}             // 显式指定切片的 索引:值 对
var _ []int = []int{2: 3}                         // 除了最后一个元素（索引为 2）的值是 3 外，其他元素都是 0
var _ [][]int = [][]int{[]int{1, 2}, []int{3, 4}} // 二维切片字面量的表示方法与数组类似，但不指定长度
var _ [][]int = [][]int{{1, 2}, {3, 4}}           // 以上二维切片的简写形式
var _ []string = []string{"dog", "sheep"}         // 元素类型为 string 的切片

// 先声明一个包含 10 个元素的数组 arr 和一个包含 10 个元素的向量 vec，用于后续的切分
let arr: [i32; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

// 通过切分数组创建切片，数组索引从 3 到 5（6-1）变为切片元素，所得切片的长度为 3（6-3）
let _: &[i32] = &arr[3..6];
let _: &[i32] = &arr[..6]; // 如果从 0 开始，若起始索引为 0，则可以省略
let _: &[i32] = &arr[3..]; // 若终止索引为数组长度，则可以省略
let _: &[i32] = &arr[..]; // 起始索引和终止索引可以同时省略，则切片引用整个数组
let _: &[i32] = &arr; // 可以将对数组的借用强制转换为切片
let _: &[i32] = arr.as_slice(); // 所得切片与以上切片等价
let _: &[i32] = &arr[..][3..6]; // 可以对切片 &arr[..] 进行再切分
let _: &[i32]; //声明切片但没有赋值，则该切片处于未初始化状态，不可用
let _: &[i32] = &[1, 2, 3]; // 强制将一个数组转换为切片
let _: &[i32] = &[]; // 注意这是一个长度和容量都为 0 的空切片，它已经初始化
let _: &[i32] = &[1; 3]; // 快速将数组中所有元素的值指定为 1
let _: &[&[i32]] = &[&[1, 2], &[3, 4]]; // 二维切片
let _: &[&str] = &["dog", "sheep"]; // 元素类型为 &str 的切片
let _: &[i32] = &vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9][..]; // 也可以通过切分向量创建切片
let _: &[i32] = &vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9].as_slice(); // 所得切片与以上切片等价
let _: &[i32] = &Box::new([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[..]; // 切分一个分配到堆上的数组
let _: &[i32] = &Box::new([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]).as_slice(); // 所得切片与以上切片等价

let _: Vec<i32> = Vec::new(); // 使用 Vec::new() 创建一个长度为 0，容量为 0 的向量
let _: Vec<i32> = vec![1, 2, 3]; // 使用 vec! 宏更加便捷地创建向量
let _: Vec<i32> = vec![0; 3]; // 创建一个长度为 3，所有元素值均为 0 的向量
let _: Vec<i32> = Vec::from([1, 2, 3]); // 从数组创建向量
let _: Vec<i32> = Vec::from(&[1, 2, 3][..]); // 从切片创建向量
let _: Vec<i32> = Vec::with_capacity(10); // 创建一个长度为 0，容量为 10 的向量

fn main() {
    let mut vec: Vec<i32> = Vec::with_capacity(10); // 创建一个长度为 0，容量为 10 的向量
    print_vector(&vec); // Len: 0, Cap: 10, Value: []

    // 依次往向量的末尾追加 0、1、2
    vec.push(0);
    vec.push(1);
    vec.push(2);
    print_vector(&vec); // Len: 3, Cap: 10, Value: [0, 1, 2]

    vec.append(&mut vec![3, 4]);
    print_vector(&vec); // Len: 5, Cap: 10, Value: [0, 1, 2, 3, 4]

    let _: i32 = vec[1]; // 获得向量的第二个元素值
    let _: Option<&i32> = vec.get(8); // 获得对向量第 9 个元素的引用，由于该值不存在，实际返回 None
    let _: Option<&[i32]> = vec.get(0..1); //获得向量的前两个元素的切片

    vec.resize(7, 0); // 调整切片的长度为 7，新加入的值为 0
    print_vector(&vec); // Len: 7, Cap: 10, Value: [0, 1, 2, 3, 4, 0, 0]

    vec.resize(5, 0); // 调整切片的长度为 5，原有的值被截断
    print_vector(&vec); // Len: 5, Cap: 10, Value: [0, 1, 2, 3, 4]

    let _: Option<i32> = vec.pop(); // 将向量末尾的值弹出，并返回该值
    vec.pop(); // 再次弹出值
    print_vector(&vec); // Len: 3, Cap: 10, Value: [0, 1, 2]

    vec.shrink_to(8); // 将切片的容量缩减到 8
    print_vector(&vec); // Len: 3, Cap: 8, Value: [0, 1, 2]

    vec.shrink_to_fit(); // 将切片的容量缩减为其长度
    print_vector(&vec); // Len: 3, Cap: 3, Value: [0, 1, 2]

    assert_eq!(vec, vec![0, 1, 2]); // 向量可以和向量比较
    assert_eq!(vec, [0, 1, 2]); // 向量和数组比较
    assert_eq!(vec, &[0, 1, 2][..]); // 向量和切片比较
}

fn print_vector(v: &Vec<i32>) {
    println!("Len: {}, Cap: {}, Value: {:?}", v.len(), v.capacity(), v)
}

func main() {
	var _ map[byte]bool                                     // 声明一个映射，但没有进行初始化
	var _ map[string]float64 = make(map[string]float64)     // 使用 make 函数初始化映射
	var _ map[string]float64 = make(map[string]float64, 10) // 创建一个容量为 10 的空映射
	var urls map[string]string = map[string]string{         // 使用映射字面量初始化映射
		"go":     "https://go.dev/",
		"rust":   "https://rust-lang.org/",
		"python": "https://www.python.org/",
		"java":   "https://www.java.com/",
	}

	fmt.Println("Go:", urls["go"]) // Go: https://go.dev/
	var _ string = urls["ruby"]    // 键 "ruby" 不存在，返回值为空 ""
	if rubyURL, present := urls["ruby"]; present {
		// 键 "ruby" 不存在, 此时 present 为 false，将什么也不打印
		fmt.Println("Ruby:", rubyURL)
	}

	fmt.Println("Len:", len(urls)) // Len: 4

	urls["javascript"] = "https://www.javascript.com/" // 添加 "javascript" 项
	delete(urls, "java")                               // 删除 "java" 项
}

use std::collections::HashMap;

fn main() {
    let _: HashMap<u8, bool>; // 声明一个 HashMap，但没有进行初始化
    let _: HashMap<String, f64> = HashMap::new(); // 使用 new 创建一个空的 HashMap
    let _: HashMap<String, f64> = HashMap::with_capacity(10); // 创建一个容量为 10 的空 HashMap

    // 通过 from 方法根据二元元组的数组创建 HashMap
    let mut urls: HashMap<&str, &str> = HashMap::from([
        ("go", "https://go.dev/"),
        ("rust", "https://rust-lang.org/"),
        ("python", "https://www.python.org/"),
        ("java", "https://www.java.com/"),
    ]);

    println!("Go: {}", urls["go"]); // Go: https://go.dev/
    // println!("Ruby: {}", urls["ruby"]); // 键 "ruby" 不存在,，将会引起 panic
    if urls.contains_key("ruby") {
        // 键 "ruby" 不存在, 因此什么也不打印
        println!("Go: {}", urls["ruby"]);
    }
    let _: Option<&&str> = urls.get("go"); // Some("https://go.dev/")
    let _: Option<&&str> = urls.get("php"); // None

    println!("Len: {}, Cap: {}", urls.len(), urls.capacity()); // Len: 4, Cap: 7

    urls.reserve(20); // 保留至少 20 个额外未用的容量
    println!("Len: {}, Cap: {}", urls.len(), urls.capacity()); // Len: 4, Cap: 28

    urls.shrink_to(10); // 以 10 为下界减少 HashMap 的容量
    println!("Len: {}, Cap: {}", urls.len(), urls.capacity()); // Len: 4, Cap: 14

    urls.shrink_to_fit(); // 尽可能缩减 HashMap 的容量
    println!("Len: {}, Cap: {}", urls.len(), urls.capacity()); // Len: 4, Cap: 7

    urls.insert(
        "javascript",
        "https://www.javascript.com/",
    ); // 添加 "javascript" 项
    // 使用 Entry API 插入元素，or_insert 仅当键值不存在时才进行插入
    urls.entry("python").or_insert("https://python.org/");
    println!("Python: {}", urls["python"]); // Python: https://www.python.org/

    urls.remove("java"); // 删除 "java" 项
}

sli := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
for i := 0; i < len(sli); i++ {
	fmt.Printf("Index: %d, Value: %d\n", i, sli[i])
}
fmt.Println()
// 使用 for-range 遍历切片
for i, v := range sli {
    fmt.Printf("Index: %d, Value: %d\n", i, v)
}
fmt.Println()

var urls map[string]string = map[string]string{
    "go":     "https://go.dev/",
    "rust":   "https://rust-lang.org/",
    "python": "https://www.python.org/",
    "java":   "https://www.java.com/",
}
// 使用 for-range 遍历映射
for k, v := range urls {
	fmt.Printf("Key: %s,\tValue: %s\n", k, v)
}

trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
    // 还包含其他许多基于 next 定义的默认方法。
}

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

// 不通过迭代器遍历向量
let mut i = 0;
while i < vec.len() {
    println!("Index: {}, Value: {}", i, vec[i]);
    i += 1;
}

// 在 vec 变量上（显式）创建迭代器。
// 后面的 next 方法以可变借用的形式使用迭代器，因此这里必须将迭代器声明为可变的
let mut vec_iter = vec.iter();
println!("{:?}", vec_iter.next()); // Some(0)
println!("{:?}", vec_iter.next()); // Some(1)
println!("{:?}", vec_iter.next()); // Some(2)，迭代器还没有被消费完

// 继续消费迭代器，将打印：
// Value: 3
// Value: 4
for v in vec_iter {
    println!("Value: {}", v);
}

// 前面声明的 vec_iter 迭代器已经被消费，要再次遍历 vec，必须重新生成一个迭代器。
// 此迭代器不必是可变的，因为下面的 for 语句取得了其所有权，并在内部使其可变
let vec_iter_new = vec.iter();
for (i, v) in vec_iter_new.enumerate() {
    println!("Index: {}, Value: {}", i, v);
}

// for 语句中若不指定创建迭代器的方法，默认将使用 into_iter() 方法
for v in vec {
    println!("Value: {}", v);
}
// vec 的所有权在以上循环中已被移动到 into_iter() 方法中，将不能再被使用
// println!("{:?}", vec);

// 声明一个可变数组，然后利用 iter_mut() 迭代修改数组的每个元素
let mut arr = [0, 1, 2, 3, 4];
for v in arr.iter_mut() {
    *v += 2;
}
// for 语句中若不指定创建迭代器的方法，默认将使用 into_iter() 方法
for v in arr {
    println!("Value: {}", v);
}
// arr 是拷贝语义的，所以还能再被使用
println!("{:?}", arr);

let urls: HashMap<&str, &str> = HashMap::from([
    ("go", "https://go.dev/"),
    ("rust", "https://rust-lang.org/"),
    ("python", "https://www.python.org/"),
    ("java", "https://www.java.com/"),
]);
// HashMap 迭代器的每个 next 返回值中包含键值对
for (k, v) in urls.iter() {
    println!("Key: {},\tValue: {}", k, v);
}

use std::collections::HashMap;

fn main() {
    let v1: Vec<char> = vec!['H', 'e', 'l', 'l', 'o'];
    // 将 char 类型的向量转换为字符串，显式标明 s1 的类型
    let s1: String = v1.iter().collect();
    println!("{s1}"); // Hello

    // 将 char 类型的向量转换为字符串，没有标明 s2 的类型，
    // 但使用 turbofish 语法标明要转换的类型
    let s2 = v1.iter().collect::<String>();
    println!("{s2}"); // Hello

    let v2 = vec![0, 1, 2, 3, 4];
    // 使用 map 迭代适配器通过闭包将原来向量的每个元素乘以 2，进而创建一个新的向量
    // 使用 turbofish 语法，同时使用形如 Vec<_> 的部分类型提示
    let v3 = v2.into_iter().map(|x| x * 2).collect::<Vec<_>>();
    println!("{:?}", v3); // [0, 2, 4, 6, 8]

    // 使用 collect 方法根据元素向量创建 HashMap
    let score_list_1 = vec![("张三", 67.5), ("李四", 88.0), ("王老五", 56.3)]
        .into_iter()
        .collect::<HashMap<_, _>>();
    println!("{:?}", score_list_1); // {"张三": 67.5, "李四": 88.0, "王老五": 56.3}

    // 先通过 zip 方法将两个迭代器合并为一个值对的迭代器，再通过 collect 方法生成 HashMap
    let names = vec!["张三", "李四", "王老五"];
    let scores = vec![67.5, 88.0, 56.3];
    let score_list_2: HashMap<_, _> = names.iter().zip(scores.iter()).collect();
    println!("{:?}", score_list_2); // {"张三": 67.5, "李四": 88.0, "王老五": 56.3}
}