23.Rust-集合(Collections)

Rust 语言标准库提供了通用的数据结构的实现。包括 向量 （Vector）、哈希表（ HashMap ）、哈希集合（ HashSet ） 。

向量 （Vector）

Rust 在标准库中定义了结构体 Vec 用于表示一个向量。向量和数组很相似，只是数组长度是编译时就确定了，定义后就不能改变了，那要么改数组，让他支持可变长度，显然 Rust 没有这么做，它用向量这个数据结构，也是在内存中开辟一段连续的内存空间来存储元素。

特点：

• 向量中的元素都是相同类型元素的集合。
• 长度可变，运行时可以增加和减少。
• 使用索引查找元素。（索引从 0 开始）
• 添加元素时，添加到向量尾部。
• 向量的内存在堆上，长度可动态变化。

创建向量

1. new() 静态方法用于创建一个结构体 Vec 的实例。

let mut 向量的变量名称 = Vec::new();

2. vec!() 宏来简化向量的创建。

let 向量的变量名称 = vec![val1,val2,...]

向量的使用方法

let mut v = Vec::new();//调用 Vec 结构的 new() 静态方法来创建向量。
v.push("Go语言极简一本通");       //通过push方法添加元素数据。并且追加到向量尾部。
v.push("Go语言微服务核心架构22讲");
v.push("从0到Go语言微服务架构师");
println!("{:?}",v);
println!("len :{}",v.len()); // 通过len方法获取向量中的元素个数。


let mut v2 = vec!["Go语言极简一本通","Go语言微服务核心架构22讲","从0到Go语言微服务架构师"];
// 通过vect!宏创建向量时，向量的数据类型由第一个元素自动推断出来。
println!("{:?}",v2);

let x=v2.remove(0);
// remove()方法移除并返回向量中指定的下标索引处的元素，将其后面的所有元素移到向左移动一位。
println!("{}",x); //输出 Go语言极简一本通
println!("{:?}",v2);//输出 ["Go语言微服务核心架构22讲", "从0到Go语言微服务架构师"]

//contains() 用于判断向量是否包含某个值。如果值在向量中存在则返回 true，否则返回 false。
if v.contains(&"从0到Go语言微服务架构师"){
   println!("找到了")
}

//访问向量中的某个元素,使用索引
let y = v[0];
println!("{}",y); //输出 Go语言极简一本通

//遍历向量
for item in v {
   println!("充电项目: {}", item);
}
//输出
充电项目: Go语言极简一本通
充电项目: Go语言微服务核心架构22讲
充电项目: 从0到Go语言微服务架构师

哈希表 HashMap

HashMap 就是键值对集合。键是不能重复的，值是可以重复的。

使用 HashMap 结构体之前需要显式导入 std::collections 模块。

创建 HashMap

使用 new()方法来创建。

let mut 变量名称 = HashMap::new();

这个哈希表只有当我们添加了元素之后才能正常使用。因为现在还没指定的数据类型。

use std::collections::HashMap;

let mut process = HashMap::new();
process.insert("Go语言极简一本通", 1);
process.insert("Go语言微服务核心架构22讲", 2);
process.insert("从0到Go语言微服务架构师", 3);

println!("{:?}", process);
//输出 {"Go语言极简一本通": 1, "Go语言微服务核心架构22讲": 2, "从0到Go语言微服务架构师": 3}
println!("len {}",menu.len());
//输出  3


// get() 方法用于根据键从哈希表中获取相应的值。
match process.get(&"从0到Go语言微服务架构师"){
   Some(v)=>{
      println!("HashMap v:{}", v);
   }
   None=>{
      println!("找不到");
  }
}
//输出 HashMap v:3

//迭代哈希表 iter()
for (k, v) in process.iter() {
   println!("k: {} v: {}", k, v);
}
//输出
k: Go语言微服务核心架构22讲 v: 2
k: 从0到Go语言微服务架构师 v: 3
k: Go语言极简一本通 v: 1

// contains_key() 方法用于判断哈希表中是否包含指定的 键值对。如果包含指定的键，那么会返回相应的值的引用，否则返回 None。
if process.contains_key(&"Go语言极简一本通") {
   println!("找到了");
}
//输出 找到了

// remove() 用于从哈希表中删除指定的键值对。如果键值对存在则返回删除的键值对，返回的数据格式为 (&'a K, &'a V)。如果键值对不存在则返回 None

let x=process.remove(&"Go语言极简一本通");
println!("{:?}",x);
println!("{:?}",process);
//输出
Some(1)
{"Go语言微服务核心架构22讲": 2, "从0到Go语言微服务架构师": 3}

哈希集合 HashSet

Hashset 是相同数据类型的集合，它是没有重复值的。如果集合中已经存在相同的值，则会插入失败。

创建 Hashset

let mut 变量名称 = HashSet::new();

常用方法如下

insert() 用于插入一个值到集合中。

    let mut studySet = HashSet::new();
    studySet.insert("Go语言极简一本通");
    studySet.insert("Go语言微服务核心架构22讲");
    studySet.insert("从0到Go语言微服务架构师");
    println!("{:?}", studySet);
    //输出 {"从0到Go语言微服务架构师", "Go语言微服务核心架构22讲", "Go语言极简一本通"}

    studySet.insert("从0到Go语言微服务架构师");
    println!("{:?}", studySet);
    //输出 {"从0到Go语言微服务架构师", "Go语言微服务核心架构22讲", "Go语言极简一本通"}

len() 方法集合中元素的个数。

println!("len:{}",studySet.len());//输出 len:3

iter() 方法用于返回集合中所有元素组成的无序迭代器。

for item in studySet.iter(){
    println!("hashSet-充电项目: {}", item);
}
//输出
hashSet-充电项目: Go语言极简一本通
hashSet-充电项目: Go语言微服务核心架构22讲
hashSet-充电项目: 从0到Go语言微服务架构师

get() 方法用于获取集合中指定值的一个引用。

match studySet.get("从0到Go语言微服务架构师") {
    None => {
        println!("没找到");
    }
    Some(data) => {
        println!("studySet中找到:{}",data);
    }
}
//输出 studySet中找到:从0到Go语言微服务架构师

contains() 方法用于判断集合是否包含指定的值。

if studySet.contains("Go语言微服务核心架构22讲"){
    println!("包含 Go语言微服务核心架构22讲")
}
//输出 包含 Go语言微服务核心架构22讲

remove() 方法用于从集合中删除指定的值。如果该值在集合中，则返回 true，如果不存在则返回 false。

  studySet.remove("Go语言极简一本通");
  println!("{:?}",studySet);//输出 {"Go语言微服务核心架构22讲", "从0到Go语言微服务架构师"}

  studySet.remove("golang");
  println!("{:?}",studySet);//输出 {"Go语言微服务核心架构22讲", "从0到Go语言微服务架构师"}