rust 初探 -- 常用的集合

rust 初探 – 常用的集合

Vector

存储在堆内存上的数据，运行时可以动态变大或者变小。
Vec 特性：

• 由标准库提供，可以存储多个相同类型的值，并且值在内存中连续存放

Vector 的创建

fn main() {     // Vec::new()     let v: Vec<i32> = Vec::new();     // 使用初始值创建，使用 vec! 宏     let v1 = vec![1,2,3]; } 

更新 Vector

fn main() {     //这里不需要指明 vec 的类型，因为后面有 push 操作会自己推断出来     let mut v = Vec::new();     v.push(1); } 

删除 Vector

和其他的 struct 结构体一样，当 Vector 离开了作用域，就会被清理掉
如果涉及到引用会不一样。

读取 Vector 的元素

fn main() {     let v = vec![1,2,3,4,5];     let third = &v[2]; // 1. 使用索引，非法访问 panic     println!("{}", third);      match v.get(2) { // 2. get 方法，非法访问 返回 None         Some(third) => println!("get {}", third),         None => println!("not exist"),     } } 

所有权和借用规则

不能在同一作用域里，对一个值不能同时有可变和不可变的引用

//vec 中内存中是连续的，新增的时候可能会重新分配，所以直接不让这样操作 fn main() {     let mut v = vec![1,2,3,4,5];     let third = &v[2]; //不可变的          v.push(6); //mutable borrow occurs here      println!("{}", third); } 

遍历 Vector 的值

fn main() { 	let mut v = vec![1,2,3,4,5]; 	for i in &mut v { 		*i += 50; 	} 	for i in v { 		println!("{}", i); 	} } 

使用 enum 来存储多种数据类型

• enum 的变体可以附加不同类型的数据
• enum 的变体定义在同一个 enum 类型下

enum Cell { 	Int(i32), 	Float(f64), 	Text(String), } // 因为类型不同，枚举的时候不好操作（很多个），需要使用到 trait 对象 fn main() { 	//编译时就知道堆上要多大的内存，而且知道所有的可能情况，编译时可以做检查 	let row = vec![ 		Cell::Int(3), 		Cell::Float(10.1), 		Cell::Text(String::from("text")), 	]; } 

字符串是什么

• Rust 的核心语言层面，只有一个字符串类型：字符串切片 str（或&str）

• 字符串切片：对存储在其他地方、UTF-8编码的字符串的引用

  • 字符串字面值：存储在二进制文件中，也是字符串切片

• String 类型：

  • 来自标准库而不是核心语言
  • 可增长、可修改、可拥有

通常说的字符串是指？

String 和 &str

• 特性：utf-8 编码

其他类型的字符串

• OsString，OsStr，CString，Cstr
• 还有一些其他第三方库

创建一个新的字符串

String::new()//用于创建一个空的字符串，是可变的 to_string()	//方法，可用于实现了 displag trait 的类型，包括字符串字面值 String::from() //函数，从字面值来创建字符串 

更新 String

• push_str() 方法：字符串切片

fn main() { 	let mut s1 = String::from("foo"); 	s1.push_str("bar");//- push_str() 方法：字符串切片  	println!("{}", s1); // foobar  	s1.push('b');//- push() 方法：单个字符 	println!("{}", s1); // foobarb } 

• • 操作符，拼接字符串

fn main() { 	let s1 = String::from("foo"); 	let s2: String = String::from("bar"); 	 	let s3 = s1 + &s2; 	//相当于 fn add(self, s: &str) -> String {} 	//&String 强制转换成 &str，解引用强制转换（deref coercion），会保留 s2 的所有权  	println!("{}", s3); 	// println!("{}", s1);//error[E0382]: borrow of moved value: `s1` 	// println!("{}", s2); } 

• format!：不会取得任意参数的所有权

use std::fmt::format;  fn main() { 	let s1 = String::from("foo"); 	let s2: String = String::from("bar"); 	let s3: String = String::from("car"); 	 	// let s4 = s1 + "-" + &s2 + "-" + &s3; 	// println!("{}", s4); //foo-bar-car 	 	let s5 = format!("{}-{}-{}", s1, s2, s3); 	println!("{}", s5);//foo-bar-car } 

内部表示

• String 是对 Vex 的包装

 String::from("hola").len(); //4，返回字节数  // unicode 标量值 

字节，标量值，字形簇

fn main() { 	let w = "测试一下"; 	for b in w.bytes() {//字节 		print!("{} ", b)//230 181 139 232 175 149 228 184 128 228 184 139  	} 	for b in w.chars() {//标量值 		print!("{} ", b)// 测 试 一 下 	} } 

访问 String

• 不支持按索引语法形式进行访问:
  • 不同语言的字符串，其对应的字节数不同
  • 索引操作应消耗一个常量时间（O(1)），而String 无法保证，需要遍历所有内容来确定有多少个合法的字符

切割 String

s = &hello[0..4]; //但是切割必须沿着字符的边界切割，否则会panic 

HashMap<K, V>

• 键值对的形式存储数据
• 适合场景，通过 K （任何类型）来寻找数据，而不是通过索引

创建 HashMap

use std::collections::HashMap;  fn main() { 	//创建 HashMap 	let mut scores = HashMap::new(); 	scores.insert(String::from("bob"), 99); //会基于此推断 k，v的类型 	// 不在 Prelude 中，所以需要添加 use  	 	//2. collect() 	let team = vec![String::from("a"), String::from("b")]; 	let t_scores = vec![10,12]; 	let hp: HashMap<_, _> = team.iter().zip(t_scores.iter()).collect(); 	// 需要指明 HashMap<_, _> } 

• 数据存储在 heap 上
• 同构的：一个 HashMap 中，所有 k 必须是同一类型，所有 v 必须是同一类型

HashMap 和所有权

• 对于实现了 Copy trait 的类型，值会被复制到 HashMap 中
• 对于拥有所有权的值（如 String），值会被移动，所有权会被转移给 HashMap
• 如果将值的引用插入到 HashMap，值本身不会移动 （被引用的值需要有效）

fn main() { 	let name = String::from("key"); 	let value = String::from("value");  	//创建 HashMap 	let mut scores = HashMap::new(); 	// scores.insert(name, value);  	// print!("{}:{}", name, value); // value borrowed here after move 	scores.insert(&name, &value);  	println!("{}:{}", name, value);//key:value } 

访问 HashMap

• get 方法，参数 K，返回 Option<&V>

use std::collections::HashMap;  fn main() { 	//创建 HashMap 	let mut scores = HashMap::new(); 	scores.insert(String::from("bob"), 90); 	scores.insert(String::from("lili"), 100);  	let name = String::from("bob"); 	let score = scores.get(&name);  	match score { 		Some(s) => println!("{}", s), // 90 		None => println!("team not exist"), 	}; }  

遍历 HashMap

use std::collections::HashMap;  fn main() { 	//创建 HashMap 	let mut scores = HashMap::new(); 	scores.insert(String::from("bob"), 90); 	scores.insert(String::from("lili"), 100);  	for (k, v) in &scores { 		println!("{}-{}", k, v)//lili-100 bob-90 	} } 

更新 HashMap

• HashMap 大小可变，每个 K 只能对应一个 V
• 更新 HashMap 中的数据，已存在 K，或者不存在 K

use std::collections::HashMap;  fn main() { 	//创建 HashMap 	let mut scores = HashMap::new(); 	scores.insert(String::from("bob"), 90); 	scores.insert(String::from("lili"), 100);  	//1. 替换现有的 v，插入两个相同k，不同 v，前者会被后者替换 	//2. 只在 K 不存在时，才插入 v 	//使用 entry 方法，结合 or_insert  	scores.entry(String::from("bob")).or_insert(80); 	scores.entry(String::from("bob2")).or_insert(80);  	println!("{:#?}", scores) }