Rust - 集合(Collections)

Rust的标准集合库提供了最常见的通用编程数据结构的有效实现，本章讨论常用集合的实现-Vector，HashMap和HashSet。

向量

Vector是可调整大小的数组，它将值存储在连续的存储块中，预定义的结构Vec可用于创建矢量，向量的一些重要特征是-

• 向量可以在运行时增长或收缩。

• 向量是同类型数据集合。

• 向量以特定顺序将数据存储为元素序列，向量中的每个元素都分配有唯一的索引号，索引从0开始到n-1，其中n是集合的大小。

• 向量只会将值附加到末端，换句话说，向量可用于实现堆栈。

• Vector的内存在堆中分配。

创建向量

let mut instance_name=Vec::new();

静态方法new()用于创建向量实例，另外，也可以使用vec!创建向量，语法如下所示-

let vector_name=vec![val1,val2,val3]

下表列出了Vec 结构的一些常用函数。

创建向量  -  new()

要创建向量，我们使用静态方法 new -

fn main() {
   let mut v=Vec::new();
   v.push(20);
   v.push(30);
   v.push(40);

   println!("size of vector is :{}",v.len());
   println!("{:?}",v);
}

上面的示例使用结构Vec中定义的静态方法new()创建了一个Vector，push(val)函数将作为参数传递的值附加到集合中，len()函数返回向量的长度。

size of vector is :3
[20, 30, 40]

创建向量 - vec! Macro

以下代码使用vec创建向量!宏，向量的数据类型被推断为分配给它的第一个值。

fn main() {
   let v=vec![1,2,3];
   println!("{:?}",v);
}

[1, 2, 3]

如前所述，向量只能包含相同数据类型的值，以下代码段将引发错误[E0308]:类型不匹配错误。

fn main() {
   let v=vec![1,2,3,"hello"];
   println!("{:?}",v);
}

push() 函数

将元素追加到集合的末尾。

fn main() {
   let mut v=Vec::new();
   v.push(20);
   v.push(30);
   v.push(40);
   
   println!("{:?}",v);
}

[20, 30, 40]

remove() 函数

删除并返回向量中位置索引处的元素，将其后的所有元素向左移动。

fn main() {
   let mut v=vec![10,20,30];
   v.remove(1);
   println!("{:?}",v);
}

[10, 30]

contains() 函数

如果切片包含具有给定值的元素，则返回true-

fn main() {
   let v=vec![10,20,30];
   if v.contains(&10) {
      println!("found 10");
   }
   println!("{:?}",v);
}

found 10
[10, 20, 30]

len() 函数

返回向量中元素的数量，也称为其"长度"。

fn main() {
   let v=vec![1,2,3];
   println!("size of vector is :{}",v.len());
}

size of vector is :3

访问向量值

向量中的各个元素可以使用其相应的索引号进行访问，以下示例创建了一个矢量，其中打印了第一个元素的值。

fn main() {
   let mut v=Vec::new();
   v.push(20);
   v.push(30);

   println!("{:?}",v[0]);
}
输出: `20`

向量中的值也可以使用对集合的引用来获取。

fn main() {
   let mut v=Vec::new();
   v.push(20);
   v.push(30);
   v.push(40);
   v.push(500);

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

20
30
40
500
[20, 30, 40, 500]

HashMap

映射是键值对的集合，映射中的两个元素都不能具有相同的键，简而言之，Map是一个查找表，HashMap将键和值存储在哈希表中，元素以任意顺序存储，该键用于在HashMap中搜索值，HashMap结构在std::collections模块中定义，应该显式导入此模块以访问HashMap结构。

创建HashMap

let mut instance_name = HashMap::new();

HashMap结构的静态方法new()用于创建HashMap对象，此方法创建一个空的HashMap。

下面讨论HashMap的常用函数-

insert()  函数

将键/值对插入到HashMap中。

use std::collections::HashMap;
fn main(){
   let mut stateCodes=HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Learnfk");
   println!("{:?}",stateCodes);
}

上面的程序创建一个HashMap并使用2个键值对对其进行初始化。

{"KL": "Kerala", "MH": "Learnfk"}

len() 函数

返回Map中的元素数

use std::collections::HashMap;
fn main() {
   let mut stateCodes=HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Learnfk");
   println!("size of map is {}",stateCodes.len());
}

上面的示例创建一个HashMap并打印其中的元素总数。

size of map is 2

get() 函数

返回对与键对应的值的引用，下面的示例在HashMap中检索键KL的值。

use std::collections::HashMap;
fn main() {
   let mut stateCodes=HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Learnfk");
   println!("size of map is {}",stateCodes.len());
   println!("{:?}",stateCodes);

   match stateCodes.get(&"KL") {
      Some(value)=> {
         println!("Value for key KL is {}",value);
      }
      None => {
         println!("nothing found");
      }
   }
}

size of map is 2
{"KL": "Kerala", "MH": "Learnfk"}
Value for key KL is Kerala

iter() 函数

返回一个迭代器，该迭代器以任意顺序包含对所有键值对的引用。

use std::collections::HashMap;
fn main() {
   let mut stateCodes=HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Learnfk");

   for (key, val) in stateCodes.iter() {
      println!("key: {} val: {}", key, val);
   }
}

key: MH val: Learnfk
key: KL val: Kerala

contains_key() 函数

如果映射包含指定键的值，则返回true。

use std::collections::HashMap;
fn main() {
   let mut stateCodes=HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Learnfk");
   stateCodes.insert("GJ","Gujarat");

   if stateCodes.contains_key(&"GJ") {
      println!("found key");
   }
}

found key

remove() 函数

从Map上删除一个键。

use std::collections::HashMap;
fn main() {
   let mut stateCodes=HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Learnfk");
   stateCodes.insert("GJ","Gujarat");

   println!("length of the hashmap {}",stateCodes.len());
   stateCodes.remove(&"GJ");
   println!("length of the hashmap after remove() {}",stateCodes.len());
}

length of the hashmap 3
length of the hashmap after remove() 2

HashSet

HashSet是一组类型T的唯一值，添加和删除值很快，并且快速询问给定值是否在集合中也很快，HashSet结构在std::collections模块中定义，应该显式导入此模块以访问HashSet结构。

创建HashSet

let mut hash_set_name=HashSet::new();

HashSet结构的静态方法new用于创建HashSet。此方法创建一个空的HashSet。

insert() 函数

向集合中添加一个值，HashSet不会将重复值添加到集合中。

use std::collections::HashSet;
fn main() {
   let mut names=HashSet::new();

   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("LearnFKPoint");
   names.insert("Mohtashim");//duplicates not added

   println!("{:?}",names);
}

{"LearnFKPoint", "Kannan", "Mohtashim"}

len() 函数

返回集合中元素的数量。

use std::collections::HashSet;
fn main() {
   let mut names=HashSet::new();
   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("LearnFKPoint");
   println!("size of the set is {}",names.len());
}

size of the set is 3

iter() 函数

返回以任意顺序访问所有元素的迭代器。

use std::collections::HashSet;
fn main() {
   let mut names=HashSet::new();
   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("LearnFKPoint");
   names.insert("Mohtashim");

   for name in names.iter() {
      println!("{}",name);
   }
}

LearnFKPoint
Mohtashim
Kannan

get() 函数

返回对该集合中的值的引用(如果有)，该引用等于给定值。

use std::collections::HashSet;
fn main() {
   let mut names=HashSet::new();
   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("LearnFKPoint");
   names.insert("Mohtashim");

   match names.get(&"Mohtashim"){
      Some(value)=>{
         println!("found {}",value);
      }
      None =>{
         println!("not found");
      }
   }
   println!("{:?}",names);
}

found Mohtashim
{"Kannan", "Mohtashim", "LearnFKPoint"}

contains() 函数

如果集合包含一个值，则返回true。

use std::collections::HashSet;

fn main() {
   let mut names=HashSet::new();
   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("LearnFKPoint");

   if names.contains(&"Kannan") {
      println!("found name");
   }  
}

found name

remove() 函数

从集合中删除一个值。

use std::collections::HashSet;

fn main() {
   let mut names=HashSet::new();
   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("LearnFKPoint");
   println!("length of the Hashset: {}",names.len());
   names.remove(&"Kannan");
   println!("length of the Hashset after remove() : {}",names.len());
}

length of the Hashset: 3
length of the Hashset after remove() : 2