rust学习笔记

# 四.数据类型

前言

rust 数据类型分为：

  • 1.标量类型：栈上存储的数据
  • 2.复合类型：堆上存储的数据
  • 3.自定义类型：自定义机构类型
  • 4.集合类型：内部提供的标准结构

# 1.标量类型

# 1.1 整型

  • 位：位是计算机中最基本的存储单位，表示二进制的一位，可以是0也可以是1
  • 位宽：又称为数据宽度，是指一个数据类型所占用的二进值位数，例如一个8位的位宽意味着他可以表示2^8，即256种不同的状态
  • 字节：字节是计算机中常用的存储单位，通常由8个位(bit)组成，即1个字节等于8个位。大多数系统中1字节=8bit,有些也可能位16bit或者32bit

# 1.1.1 分类

  • 整型默认类型为i32
  • arch长度是指在32位硬件和操作系统上是32-bit的isize,在64位硬件和操作系统上是i64的usize
# 1.1.1.1 有符号整数

i前缀

let number: i32 = 42;
1

具体有i8、i16、i32、i64、i128、isize

# 1.1.1.2 无符号整数

u前缀

let number: u64 = 100;
1

具体有u8、u16、u32、u64、u128、usize

# 1.1.1.3 字面量

可以带上类型和_类型分隔

  • 字节：一个字节等于8个位bit
let a:u8 = b'A';
1
  • 二进制:0b开头
let a:u8=0b1111_0000;
let b = 0b1111_0000u8;
let c = 0b1111_0000_u8;
1
2
3
  • 八进制:0o开头
let a:i8=0o77;
let b=0o77i8;
let c=0o77_i8;
1
2
3
  • 十进制:默认写，支持千分符分隔
let a:u32=1_234_567;
let b=1_234_567u32;
let c= 1_234_567_u32;
1
2
3
  • 十六进制:0x开头
let a:u8=0xFF;
let b =0xFFu8;
let c=0xFF_u8;
1
2
3

# 1.1.2 创建

# 1.1.3 类型转换

通过as关键字设置要转换的类型

  • i8转i16
let num:i8=10;
let b = num as i16;
1
2
  • 断言
assert_eq!(10_i8 as u16,10_u16)
1

# 1.1.4 溢出处理

  • 如果一个较大位宽的数据向较小位宽的数据转换时，可能会发生截断
assert_eq!(1000_i16 as u8,232_u8);
1

溢出处理 rust中除了使用+、-、*、/来进行运算外，还提供一些方法来进行运算

  • Checked：返回一个Option类型，如果没有溢出返回Some(v),有溢出返回None
10u8.checked_add(100); // Some(100);
128u8.checked_add(200); // None;
1
2
  • Wrapping：没有溢出，返回对应的值，有溢出，返回结果对2的n次方取模，其中n是预期位宽
100_u16.wrapping_mul(200); // => 20000
900_u16.wrappiing_mul(900); // => 23568 810000 & 2^16 =>23568
1
2
  • Staturating:针对溢出的结果，钳制到对应位宽可以表达的最大值和最小值
32760_i16.staturating_add(10); // => 32767;
(-32760_i16).staturation_sub(10); // => -32768;
1
2
  • Overflowing:返回一个2元枚举类型，第一个表示结果，第二个是布尔值表示是否溢出
255_u8.overflowing_sub(2); // =>(253,false)
255_u8.overflowing_add(2);// =>(1,true)
1
2

# 1.2 浮点数

浮点数有两种主要类型：f32和f64。f32是单精度浮点数，f64是双精度浮点数。默认为 f64占64位。

# 1.2.1 类型

# 1.2.1.1 单精度浮点数

f32表示单精度浮点数，表示范围为-3.4 x 10^38 至 +3.4 x 10^38

let float_number: f32 =3.14
1
# 1.2.1.2 双精度浮点数

f64表示双精度浮点数，表示范围为-1.8 x 10^308 至 + 1.8^308

let double_number: f64 = 3.1415926
1

# 1.2.2 创建

# 1.2.3 方法

  • 1.pow:计算整数的幂
let x = 4i32;
println!("{}",x.pow(10))
1
2
  • 2.abs:绝对值
let x = -3.5_f64;
println!("{}",x.abs())
1
2
  • 3.round:四舍五入
let x = 3.5_f64;
println!("{}",x.round())
1
2
  • 4.ceil:向上取整
let x = 3.5_f64;
println!("{}",x.ceil())
1
2
  • 5.floor:向下取整
let x = 3.5_f64;
println!("{}",x.floor())
1
2
  • 6.powf:幂运算（浮点型）
let x = 4.11f32;
println!("{}",x.powf(10.0))
1
2

# 1.3 字符

  • 在rust中字符类型是使用''引起来的单个字符，它代表了这个字符的Unicode值，对应的是一个32-bit的整数值，也就是说，一个char类型占用4字节，取值范围为0x0000 - 0xD7FF,以及 0xE000 - 0x10FFFF

  • 使用\作为转义字符

# 1.3.1 创建

  • 字符类型使用单引号'表示
let word:char = 'A'
1

# 1.4 布尔值

# 1.4.1 创建

  • 值为true或false
let value:bool = true
1

# 1.4.2 转换

布尔值通过as转换为整数

let t = true;
let b = t as u8;
println!("{}",b)
1
2
3

# 2.复合类型

# 2.1 数组

  • 数组固定大小，且所有元素类型必须相同，使用[]表示

# 2.1.1 创建

  • 指定类型和长度
  • 类型为统一类型
let arr:[i32; 3] = [1,2,3]
1
  • 默认值
let arr: [i32; 5] = [-1; 5];
1

# 4.8.2 增

数组是静态的，这意味着数组一旦初始化就无法调整大小

# 4.8.3 删

数组值可以更新和修改，但不能删除

# 4.8.4 改

  • 1.index
let mut arr: [i32; 5] = [-1; 5];
arr[1]=6;
1
2

# 4.8.5 查

  • 1.index
let mut arr: [i32; 5] = [-1; 5];
let val = arr[1];
1
2
  • 2.len
let mut arr: [i32; 5] = [-1; 5];
println!("{}",arr.len())
1
2
  • 3.is_empty
let mut arr: [i32; 5] = [-1; 5];
println!("{}",arr.is_empty())
1
2
  • 4.first
  • 5.first_mut
  • 6.last
  • 7.last_mut
  • 8.get
  • 9.get_mut
  • 10.contains
  • 11.starts_with
  • 12.repeat
  • 13.fill
  • 14.swap

# 4.8.6 遍历

  • 1.for in
let mut arr: [i32; 5] = [-1; 5];
for i in 0..5{
    println!("{:?}",arr[i])
}
1
2
3
4
  • 2.iter
let mut arr: [i32; 5] = [-1; 5];
for i in arr.iter(){
    println!("{:?}",i)
}
1
2
3
4

# 2.2 元祖

  • 存储多个不同类型的值，使用()表示

# 2.2.1 创建

let tuple:(i32,f64,char)=(42,3.14,'A')
1

# 2.2.2 增

# 2.2.3 删

# 2.2.4 改

# 2.2.5 查

let a = (1,2,3);
let b = a.1;
println!("{}",b);
1
2
3

# 2.2.6 遍历

# 2.3 切片

  • 引用数组或向量的一部分数据，使用&[T]表示

# 2.3.1 创建

let arr: [i32; 5] = [1, 2, 3, 4, 5];
let slice: &[i32] = &arr[..3]; // 引用数组
1
2

# 2.3.2 增

# 2.3.3 删

# 2.3.4 改

# 2.3.5 查

# 2.3.6 遍历

# 2.4 字符串

字符串包含：容量

  • 字符串有两种类型:str、String，str类似于切片，总是通过引用的方式使用

# 2.4.1 创建

  • 1.字面量方式

可以不用指定类型，rust 会自动推导

let a = "aaa";
// let a: &str= "aaa"; // &str类型
1
2
  • 2.new

创建一个空的 String 对象

let string: String= String::new();// "String类型"
1
  • 3.from

从一个字符串字面量、一个字节数组或另一个字符串对象中创建一个新的 String 对象

let s1 :String = String::from("hello"); // "hello"
let s2:String = String::from_utf8(vec![1,3,43,5,6]).unwrap()
let s3:String= String::from(s1)
1
2
3
  • 4.witch_capacity

创建一个具有指定容量的 String 对象

let mut s= String::witch_capacity(10);
s.push("a")
1
2
  • 5.capacity

返回字符串的容量（已字节为单位）

let mut s= String::witch_capacity(10);
assert_eq!(s.capacity(),10)
1
2
  • 6.clone

创建一个与原始字符串相同的新字符串

let s1 = String::from("hello");
let s2 = s1.clone();
1
2

# 2.4.2 添加

  • 1.push

将一个字符追加到字符串末尾

let mut s = String::from("abc");
s.push('!') ;//追加字符 -> "abcobb!"
1
2
  • 2.push_str

将一个字符串追加到字符串末尾

let mut s = String::from("abc");
s.push_str("obb"); // 追加字符串切片
1
2

# 2.4.3 删除

  • pop

将字符串的最后一个字符弹出，并返回他

let mut s = String::from("hello");
let last = s.pop();
1
2

# 2.4.4 分割

  • split

将字符串分割为一个迭代器，每个元素都是一个子字符串

let s = String::from("hello,world");
let mut iter=s.split(",");
assert_eq!(iter.next(),Some("hello"))
assert_eq!(iter.next(),Some("world"));
assert_eq!(iter.next(),None)
1
2
3
4
5

# 2.4.5 查询

  • len

返回字符串的长度（以字节为单位）

let s = "你好";
let len = s.len(); // 值为6，长度算的是编码长度
1
2
  • count
let s = String::from("heasd中国");
let len = s.chars().count();//7
1
2
  • chars

将字符串分割为一个迭代器，每个元素都是一个字符

let s = String::from("heasd中国");
for c in s.chars() {
    println!("数据是: {c}");
}
// 数据是: h
// 数据是: e
// 数据是: a
// 数据是: s
// 数据是: d
// 数据是: 中
// 数据是: 国
1
2
3
4
5
6
7
8
9
10
11
  • is_empty

检查字符串是否为空

let s = String::from("");
assert!(s.is_empty());
1
2
  • eq

比较两个字符串是否相等

let s1 = String::from("hello");
let s2 = Stirng::from("hello");
assert!(s1.eq(s2));
1
2
3
  • contains

检查字符串是否包含指定的子字符串

let s = Stirng::from("hello");
assert!(s.contents("e"));
1
2
  • starts_with

检查字符串是否以指定的前缀开头

let s = String::from("hello");
assert!(s.starts_width("he"));
1
2
  • ends_with

检查字符串是否以指定后缀结尾

let s = String::from("hello");
assert!(s.ends_with("lo"));
1
2
  • find

查找字符串中第一个匹配指定字符串的位置

let s = String::from("hello");
let pos = s.find("1");
assert_eq!(pos,Some(2));
1
2
3

# 2.4.6 转换

  • str-> String
let a: &str = "asdfasd";
let b: String = a.to_string();
1
2
let a: &str = "asdfasd";
let b: String = String::from(a);d
1
2
let aaa ="aaaa";
let bbb = aaa.to_owned();
1
2
  • String -> &str

&String类型自动转为&str类型，会自动解引用为&str

let b: String = String::from("asdfasd");
let a: &str = &b;
1
2

# 4.8.1 创建

# 4.8.2 增

# 4.8.3 删

# 4.8.4 改

# 4.8.5 查

# 4.8.6 遍历

# 2.4.6 类型转换

  • to_string

将其他类型转为字符串

let one = 1.to_string() //  整数转字符串
let float = 1.3.to_string() // 浮点数转字符串
let slice = "slice".to_string(); // 字符串切片转字符串
1
2
3
  • as_bytes

将 String 对象转换为字节数组

let s = String::from("hello");
let bytes = s.as_bytes();
1
2
  • into_bytes

将 String 对象转换为字节向量

let s = String::from("hello");
let bytes = s.into_bytes();
assert_eq!(&[104,101][..],&bytes[..])
1
2
3
  • as_str

将 String 对象转换为字符串切片

let s = String::from("hello");
let slice = a.as_str();
1
2
  • as_mut_str

将 String 对象转换为可变字符串切片

let mut s = String::from("foobar");
let s_mut_str = s.as_mut_str()
s_mut_str.make_ascii_uppercase()
assert_eq!("FOOBAR",s_mut_str)
1
2
3
4
  • trim

删除字符串两端的所有空格

let s = String::from("   hello  ");
let trim = s.trim();
1
2
  • to_lowercase

将字符串中的所有字符转换为小写

let s = String::from("HeLLO");
let lower = s.to_lowsercase();
1
2
  • to_uppercase

将字符串中的所有字符转换为大写

let s = String::from("HeLLo");
let upper = s.to_uppercase();
1
2
  • retain

保留满足指定条件的所有字符，即筛选

let mut s = String::from("hello");
s.retain(|c| c!='1')
1
2

# 2.4.7 字符串拼接

  • +连接
let s1 = String::from("hello,");
let s2 = String::from("world!");
let s3 = s1 + &s2;//"hello,world!"
1
2
3
  • format
let s1 = String::from("hello,")
let s2 = String::from("world!")
let s3 = format!("{}-{}",s1,s2)
1
2
3

# 3.自定义类型

# 3.1 结构体类型

  • 名称采用大驼峰命名法，属性采用键值对命名法
  • 定义复杂的数据结构，使用struct关键字定义

# 3.1.1 创建

  • 名值对
struct  Student{
    active:bool,
    usernanme:String,
    email:String,
    sign_in_count:u64
}

let student=Student {
    active:true,
    usernanme:"小明".to_string(),
    email:"abc@ss.com".to_string(),
    sign_in_count:9
};
1
2
3
4
5
6
7
8
9
10
11
12
13
  • 元祖式
struct Point(f32, f32);
let point = Point(1.0, 2.0);
1
2
  • 单元式
struct AlwaysEqual;
1
  • 注意点：所有权转移
struct Student {
    active: bool,
    usernanme: String,
    email: String,
    sign_in_count: u64,
}

let student = Student {
    active: true,
    usernanme: "小明".to_string(),
    email: "abc@ss.com".to_string(),
    sign_in_count: 9,
};
let name = student.usernanme;
println!("{}",student.usernanme); // 错误
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

可以使用只读引用来避免此问题let name = &student.usernanme;

# 3.1.2 增

使用impl为结构体增加方法

# 3.1.3 删

# 3.1.4 改

# 3.1.5 查

  • 1.解构方式访问
struct Point(f32, f32);
let point = Point(1.01, 2.0);
println!("{} {}",point.0,point.1)
1
2
3

# 3.1.6 遍历

# 3.2 枚举类型

  • 定义具有不同变体的类型，使用enum关键字定义，可以携带不同类型的数据,访问数据使用::
  • 使用impl为枚举添加方法，访问方法使用::

# 3.2.1 创建

#[derive(Debug)]

enum Book {
    Papery,
    Electronic,
}

fn main() {
    let book = Book::Papery;
    println!("{:?}", book);
}
1
2
3
4
5
6
7
8
9
10
11
  • 为枚举映射不同类型的值
enum Book {
    Papery,//单个数值
    A=1,//指定数值
    B(String), // ()内为参数类型，参数为固定位置
    Electronic {x:i32,y:i32},//{}内为参数名称及类型
}
1
2
3
4
5
6

# 3.2.2 增

# 3.2.3 删

# 3.2.4 改

# 3.2.5 查

# 3.2.6 匹配

#[derive(Debug)]

enum HttpStatus {
    Ok = 200,
    NotModified = 304,
    NotFound = 404,
}

fn main() {
impl HttpStatus {
    fn from_u32(n:u32) ->Option<HttpStatus>{
        match  n {
            200 => Some(HttpStatus::Ok),
            304 => Some(HttpStatus::NotModified),
            404 => Some(HttpStatus::NotFound),
            _=>None
        }
    }
}
let status = HttpStatus::from_u32(300);
println!("{:?}",status);//Some(NotModified)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 3.2.7 Option

# 3.2.7.1 基础
  • Some 代表有，可以通过 if、let、match、umwrap、?等方式取出Some包裹的值
  • None 代表无
pub enum Option<T>{
    None,
    Some(T)
}
1
2
3
4
# 3.2.7.2 方法
  • 1.is_none：判断Option是否为None
  • 2.is_some：检查Option<T>是否为Some<T>
  • 3.unwrap：返回T的值。如歌为None则会发生异常，会消费Option本身的值，后面就不能再用了
  • 4.unwrap_or：Option<T>为Some<T>则返回包裹的值，否则返回调用函数时候的默认值，例如：Some("car").unwrap_or("bike")
  • 5.take:取出可变引用所指向的值并将其替换为 None ,然后返回原来的值作为Option(取出值并将其标记为已取出的时候会用到)

# 3.2.8 Result

# 3.2.8.1 基础
  • 检查值的存在性
  • Ok 代表正确，可以通过 match、umwrap等方式取出Ok包裹的值
  • Err 代表错误
enum Result<T,E>{
    Ok(T),
    Err(E)
}
1
2
3
4
# 3.2.8.2 方法
  • 1.is_ok：检查是否成功
  • 2.is_err：检查是否错误
  • 3.unwrap：尝试获取期望值，如果此时结果是错误的，则会发生panic
  • 4.unwrap_or：尝试获取期望值，如果结果是错误的，则使用传入参数替代

# 3.3 引用类型

  • 引用类型用于引用其他变量的值，而不是拥有自己的所有权，使用&符号表示
let val:i32 = 42
let refer: &i32=&value
1
2

# 3.3.1 只读引用

用&表示

# 3.3.1.1 共享访问

# 3.3.2 可写引用

# 3.3.2.1 排他访问

用&mut表示

# 3.3.3 解引用

用*表示

# 3.5 函数类型

  • 函数类型由函数的参数类型和返回类型组件
fn add(a:i32,b:i32) -> i32 {
  a + b
}
1
2
3

# 3.6 范围类型

  • 左闭右开
use std::ops::{Range, RangeInclusive}
let val = (1..5)
let val2 = Range{ start: 1, end: 5 }
1
2
3
  • 全闭
use std::ops::{Range, RangeInclusive}
let val = (1..=5)
let val2 = RangeInclusive::new(1, 5)
1
2
3

# 4.集合类型

# 4.1 向量

  • 向量在栈上包含：指针、容量、长度
  • 存储可变大小的元素序列，使用Vec<T>表示

# 4.1.1 创建

  • 1.通过new方式
let mut vector:Vec<i32> = Vec::new()
1
  • 2.通过vec!方式
let vector:Vec<i32> = vec![];
let mut vector = vec![1,1];
1
2

# 4.1.2 增

  • 1.push
let mut vector = vec![1,1];
vector.push(12);
1
2
  • 2.insert
let mut vector = vec![1,1];
vector.insert(0,100);
1
2

# 4.1.3 删

  • 1.pop
let mut vector = vec![1,1];
vector.pop();
1
2
  • 2.remove
let mut vector = vec![1,2];
vector.remove(1);
1
2
  • 3.clear
let mut vector = vec![1,2];
vector.clear();
1
2

# 4.1.4 改

  • 1.swap
let mut vector = vec![1,2];
vector.swap(0,1);
1
2
  • 2.reverse
let mut vector = vec![1,2];
vector.reverse();
1
2
  • sort
let mut vector = vec![100,1,6,0,2];
vector.sort();
1
2
  • 4.retain
let mut vector = vec![1,2];
vector.retain(|&x| x % 2 == 0);
1
2

# 4.1.5 查

  • 1.first：获取集合第⼀个元素的只读引⽤
let mut vector = vec![100,1,6,0,2];
let val = vector.first();
1
2
  • 2.first_mut：获取集合第⼀个元素的可写引⽤
let mut vector = vec![100,1,6,0,2];
let val = vector.first_mut();
1
2
  • 3.get(index)：获取集合⼀个或者⼀段元素的切⽚引⽤
let mut vector = vec![100,1,6,0,2];
let val = vector.get(0);
1
2
  • 4.get_mut(index)：获取集合⼀个或者⼀段元素的可写切⽚引⽤
let mut vector = vec![100,1,6,0,2];
let val = vector.get_mut(0);
1
2
  • 5.last()： 获取集合最后⼀个元素的只读引⽤
let mut vector = vec![100,1,6,0,2];
let val = vector.last();
1
2
  • 6.last_mut()：获取集合最后⼀个元素的可写引⽤
let mut vector = vec![100,1,6,0,2];
let val = vector.last_mut();
1
2

# 4.1.6 遍历

  • 1.for v in vec Vector 中的值都被移出，发⽣所有权转移，也叫做 Vector 被消费了（consume）
let mut vector = vec![100, 1, 6, 0, 2];
for v in vector {
    println!("{}", v)
}
1
2
3
4
  • 2.for v in &vec 以只读引⽤的⽅式遍历 Vector 中的值
let mut vector = vec![100, 1, 6, 0, 2];
for v in &vector {
    println!("{}", v)
}
1
2
3
4
  • 3.for v in &mut vec 以可写引⽤的⽅式遍历 Vector 中的值
let mut vector = vec![100, 1, 6, 0, 2];
for v in &mut vector {
    println!("{}", v)
}
1
2
3
4

# 4.2 双端队列

# 4.2.1 创建

# 4.2.2 增

# 4.2.3 删

# 4.2.4 改

# 4.2.5 查

  • first：获取集合第⼀个元素的只读引⽤
  • first_mut：获取集合第⼀个元素的可写引⽤
  • get(index)：获取集合⼀个或者⼀段元
  • 素的切⽚引⽤
  • get_mut(index)：获取集合⼀个或者⼀段元素的可写切⽚引⽤
  • last()： 获取集合最后⼀个元素的只读引⽤
  • last_mut()：获取集合最后⼀个元素的可写引⽤

# 4.3 双向列表

# 4.3.1 创建

# 4.3.2 增

# 4.3.3 删

# 4.3.4 改

# 4.3.5 查

  • first：获取集合第⼀个元素的只读引⽤
  • first_mut：获取集合第⼀个元素的可写引⽤
  • get(index)：获取集合⼀个或者⼀段元
  • 素的切⽚引⽤
  • get_mut(index)：获取集合⼀个或者⼀段元素的可写切⽚引⽤
  • last()： 获取集合最后⼀个元素的只读引⽤
  • last_mut()：获取集合最后⼀个元素的可写引⽤

# 4.4 最大堆

# 4.5 键值对哈希表

# 4.5.1 创建

  • HashMap:#new() 创建⼀个哈希表类型的值
  • HashMap:#with_capacity(capacity) 使⽤指定的容量创建⼀个哈希表类型的值
  • new
use std::collections::HashMap;

fn main(){
    let mut map = HashMap::new();
    map.insert("color","red");
    map.insert("size","111");
    println!("{}",map.get("color").unwrap())
}
1
2
3
4
5
6
7
8

# 4.5.2 增

  • insert

插入新的数据

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);
    }
}
1
2
3
4
5
6
7
8
9
10
  • entry
map.entry("color").or_insert("red");
1
  • get_mut
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";
    }
}
1
2
3
4
5
6
7
8
9
10
  • map.insert(key, value) 插⼊⼀组键值对
  • map.append(&mut map2) 把 map2 中的键值对都移动到 map 中

# 4.5.3 删

  • map.remove(&key) 移除给定的 Key。返回值是 Option
  • map.remove_entry(&key) 移除给定的 Key。返回值是 Option<(K, V)>
  • map.clear() 清空哈希表

# 4.5.4 改

# 4.5.5 查

  • map.len() 哈希表的长度，也就是其中包含的键值对的数量
  • map.is_empty() 哈希表是否为空
  • map.contains_key(&key) 检测给定的 Key 是否存在
  • map.get(&key) 根据给定的 Key 获取键值对的值。如果存在，则返回 Some(v)，
  • 如果不存在则返回 None
  • map.get_mut(&key) 根据给定的 Key 获取键值对的值的可写引⽤
  • get

获取值

map.get("color")
1
  • contains_key

检查哈希表中是否包含特定的键

obj.contains_key("target")
1
  • first：获取集合第⼀个元素的只读引⽤
  • first_mut：获取集合第⼀个元素的可写引⽤
  • get(index)：获取集合⼀个或者⼀段元
  • 素的切⽚引⽤
  • get_mut(index)：获取集合⼀个或者⼀段元素的可写切⽚引⽤
  • last()： 获取集合最后⼀个元素的只读引⽤
  • last_mut()：获取集合最后⼀个元素的可写引⽤

# 4.6 有序键值对表

# 4.6.1 创建

# 4.6.2 增

# 4.6.3 删

# 4.6.4 改

# 4.6.5 查

  • first：获取集合第⼀个元素的只读引⽤
  • first_mut：获取集合第⼀个元素的可写引⽤
  • get(index)：获取集合⼀个或者⼀段元
  • 素的切⽚引⽤
  • get_mut(index)：获取集合⼀个或者⼀段元素的可写切⽚引⽤
  • last()： 获取集合最后⼀个元素的只读引⽤
  • last_mut()：获取集合最后⼀个元素的可写引⽤

# 4.7 无序哈希集合

  • HashSet:#new 创建⼀个哈希集合类型的值
  • HashSet:#with_capacity(capacity) 使⽤给定的容量创建⼀个哈希集合类型的值
  • set.len() 哈希集合的长度
  • set.is_empty() 检测是否为空
  • set.contains(&value) 检测是否包含给定的值
  • set.insert(value) 插⼊⼀个值
  • set.remove(&value) 移除⼀个值
  • set.get(&value) 获取⼀个和给定值相等的值
  • set.take(&value) 获取并转移所有权
  • set.replace(value) 替换⼀个现有的值

# 4.7.1 创建

# 4.7.2 增

# 4.7.3 删

# 4.7.4 改

# 4.7.5 查

  • first：获取集合第⼀个元素的只读引⽤
  • first_mut：获取集合第⼀个元素的可写引⽤
  • get(index)：获取集合⼀个或者⼀段元
  • 素的切⽚引⽤
  • get_mut(index)：获取集合⼀个或者⼀段元素的可写切⽚引⽤
  • last()： 获取集合最后⼀个元素的只读引⽤
  • last_mut()：获取集合最后⼀个元素的可写引⽤

# 4.8 有序集合

# 4.8.1 创建

# 4.8.2 增

# 4.8.3 删

# 4.8.4 改

# 4.8.5 查

  • first：获取集合第⼀个元素的只读引⽤
  • first_mut：获取集合第⼀个元素的可写引⽤
  • get(index)：获取集合⼀个或者⼀段元
  • 素的切⽚引⽤
  • get_mut(index)：获取集合⼀个或者⼀段元素的可写切⽚引⽤
  • last()： 获取集合最后⼀个元素的只读引⽤
  • last_mut()：获取集合最后⼀个元素的可写引⽤

← 五.内置对象 →