建设征婚网站,网站制作步骤流程图,医院网站怎么做,网站开发各个文件查看本地官方文档
安装rust后运行
rustup doc查看The Standard Library即可获取标准库内容
std::vec::Vec定义
Vec除了可以作为动态数组还可以模拟为一个栈#xff0c;仅使用push、pop即可
Vec默认分配在堆上#xff0c;对于一个容量为4#xff0c;有两个元素a、b的向量…查看本地官方文档
安装rust后运行
rustup doc查看The Standard Library即可获取标准库内容
std::vec::Vec定义
Vec除了可以作为动态数组还可以模拟为一个栈仅使用push、pop即可
Vec默认分配在堆上对于一个容量为4有两个元素a、b的向量内存布局如下 ptr len capacity------------------------| 0x0123 | 2 | 4 |------------------------|v
Heap --------------------------------| a | b | uninit | uninit |--------------------------------Vec定义
pub struct VecT, A: Allocator Global {// 存储了动态数组的元素数据并且根据需要可以动态地增长或收缩以容纳更多或更少的元素buf: RawVecT, A,// 表示当前Vec中实际存储的元素数量len: usize,
}RawVec定义
pub(crate) struct RawVecT, A: Allocator Global {// 这是一个UniqueT类型的指针指向分配的内存块中存储元素的起始位置。这个指针用于访问和操作存储在RawVec中的元素ptr: UniqueT,// 代表RawVec的容量容量通常会随着元素的添加而动态调整当需要更多空间时会进行内存重新分配以增加容量。同时对于零大小类型ZST容量的处理方式有所不同capacity()方法会在这种情况下返回usize::MAXcap: Cap,// 分配器负责分配和释放内存以及管理内存的生命周期通过这个分配器RawVec可以根据需要动态地分配和调整内存空间来存储元素alloc: A,
}每次进行自动分配容量的开销比预先分配容量大得多所以预先分配容量可以减少分配的开销建议使用with_capacity预先分配容量
方法
with_capacity创建一个具有指定初始容量的Vec
fn main() {let mut v Vec::with_capacity(5);v.push(1);v.push(2);println!(Capacity: {}, v.capacity()); // 输出初始容量 5目前只使用了部分容量// Capacity: 5
}from_raw_parts从给定的原始指针和长度创建一个Vec使用时需要非常小心确保内存管理正确
ptr必须使用全局分配器进行分配例如通过alloc::alloc函数T需要和ptr的对齐方式相同。不那么严格的对齐是不够的对齐确实需要相等才能满足dealloc要求即内存必须以相同的布局分配和释放。T的大小乘以容量即分配的大小以字节为单位需要与指针分配的大小相同。因为与对齐类似必须以相同的布局大小调用dealloc。Length必须小于或等于capacity容量第一个Length值必须正确初始化T类型的值容量需要是指针分配的容量分配的字节大小必须不大于isize::MAX
use std::ptr;
use std::mem;
fn main() {let v vec![1, 2, 3];let mut v mem::ManuallyDrop::new(v);let p v.as_mut_ptr();let len v.len();let cap v.capacity();unsafe {// 覆盖内存for i in 0..len {ptr::write(p.add(i), 4 i);}// 将内存重新构建为Veclet rebuilt Vec::from_raw_parts(p, len, cap);println!({:?}, rebuilt);// [4, 5, 6]}
}capacity返回Vec的当前容量
fn main() {let mut v Vec::with_capacity(5);v.push(1);v.push(2);println!(Capacity: {}, v.capacity()); // 输出初始容量 5目前只使用了部分容量// Capacity: 5
}reserve增加Vec的容量确保至少可以容纳指定数量的更多元素
fn main() {let mut v: Veci32 Vec::new();v.reserve(10);println!(Capacity after reserve: {}, v.capacity());// Capacity after reserve: 10
}reserve_exact精确地将Vec的容量调整为指定值容量为vec.len()addtitional
fn main() {let mut v Vec::new();v.push(1);v.push(2);v.reserve_exact(5);println!(Capacity after reserve_exact: {}, v.capacity());// Capacity after reserve_exact: 7
}try_reserve尝试增加Vec的容量如果无法增加则返回false
fn main() {let mut v: Veci32 Vec::new();if v.try_reserve(1).is_ok() {println!(Reserved successfully);// Reserved successfully} else {println!(Failed to reserve);}
}try_reserve_exact尝试将Vec的容量精确调整为指定值如果无法调整则返回false
fn main() {let mut v: Veci32 Vec::new();if v.try_reserve_exact(5).is_ok() {println!(Reserved exactly successfully);// Reserved exactly successfully} else {println!(Failed to reserve exactly);}
}shrink_to_fit将Vec的容量调整为与当前长度相等释放多余的内存
fn main() {let mut v Vec::with_capacity(10);v.push(1);v.push(2);v.shrink_to_fit();println!(Capacity after shrink_to_fit: {}, v.capacity());// Capacity after shrink_to_fit: 2
}shrink_to尽可能将Vec的容量缩小为指定最小容量释放多余的内存
fn main() {let mut v Vec::with_capacity(10);v.push(1);v.push(2);v.shrink_to(1);println!(Capacity after shrink_to_fit: {}, v.capacity());// Capacity after shrink_to_fit: 2
}into_boxed_slice将Vec转换为Box[T]所有权转移
fn main() {let v vec![1, 2, 3];let boxed_slice v.into_boxed_slice();println!({}, boxed_slice[0]);// 1
}truncate截断Vec使其长度不超过指定值
fn main() {let mut v vec![1, 2, 3, 4, 5];v.truncate(3);println!(Truncated vector: {:?}, v);// Truncated vector: [1, 2, 3]
}as_slice返回Vec的不可变切片引用
fn main() {let v vec![1, 2, 3];let slice v.as_slice();for item in slice {println!({}, item);}// 1// 2// 3
}as_mut_slice返回Vec的可变切片引用
fn main() {let mut v vec![1, 2, 3];let slice v.as_mut_slice();slice[0] 4;println!(Modified vector: {:?}, v);// Modified vector: [4, 2, 3]
}as_ptr返回指向向量缓冲区的原始指针或悬空的原始指针
fn main() {let x vec![1, 2, 4];let x_ptr x.as_ptr();unsafe {for i in 0..x.len() {// 将指针加i即右移i位然后解引用得到对应位置的元素124// 1按位左移相当于*2assert_eq!(*x_ptr.add(i), 1 i);}}
}as_mut_ptr返回指向Vec缓冲区的不安全可变指针或悬空的指针
fn main() {let size 4;let mut x: Veci32 Vec::with_capacity(size);let x_ptr x.as_mut_ptr();// 初始化原始指针并设置长度unsafe {for i in 0..size {*x_ptr.add(i) i as i32;}x.set_len(size);}println!({:?}, x);// [0, 1, 2, 3]
}set_len低级操作用于修改向量长度
new_len必须小于或等于 capacity()必须初始化元素
fn main() {let size 4;let mut x: Veci32 Vec::with_capacity(size);let x_ptr x.as_mut_ptr();// 初始化原始指针并设置长度unsafe {for i in 0..size {*x_ptr.add(i) i as i32;}x.set_len(size);}println!({:?}, x);// [0, 1, 2, 3]
}swap_remove从Vec中删除一个元素并返回它被删除的元素位置将被Vec的最后一个元素替换不保留其余元素的顺序如果需要保留元素顺序请使用remove
fn main() {let mut v vec![foo, bar, baz, qux];let _ v.swap_remove(1);println!({:?}, v);// [foo, qux, baz]
}insert在指定位置插入一个元素
fn main() {let mut v vec![1, 2, 3];v.insert(1, 4);println!(Inserted vector: {:?}, v);// Inserted vector: [1, 4, 2, 3]
}remove移除指定位置的元素并返回它同时调整向量的长度
fn main() {let mut v vec![1, 2, 3];let removed v.remove(1);println!(Removed element: {}, removed);// Removed element: 2println!(After removal: {:?}, v);// After removal: [1, 3]
}retain保留满足给定谓词的元素删除不满足的元素
fn main() {let mut v vec![1, 2, 3, 4];v.retain(|x| x % 2 0);println!(Retained vector: {:?}, v);// Retained vector: [2, 4]
}retain_mut保留满足给定谓词的元素删除不满足的元素并且可以在过程中修改元素
fn main() {let mut v vec![1, 2, 3, 4];v.retain_mut(|x| {if *x % 2 0 {*x * 2;true} else {false}});println!(After retain_mut: {:?}, v);// After retain_mut: [4, 8]
}dedup_by_key根据自定义的键提取函数去除连续重复的元素
fn main() {let mut vec vec![10, 20, 21, 30, 20];vec.dedup_by_key(|i| *i / 10);println!({:?}, vec);// [10, 20, 30, 20]
}dedup_by使用自定义的比较函数去除连续重复的元素
fn main() {let mut v vec![1, 2, 2, 3];v.dedup_by(|a, b| a b);println!(After dedup_by: {:?}, v);// After dedup_by: [1, 2, 3]
}push向Vec的末尾添加一个元素
fn main() {let mut v Vec::new();v.push(1);v.push(2);println!(Pushed vector: {:?}, v);// Pushed vector: [1, 2]
}pop移除并返回Vec的末尾元素如果Vec为空则返回None
fn main() {let mut v vec![1, 2, 3];if let Some(item) v.pop() {println!(Popped item: {}, item);// Popped item: 3}println!(After pop: {:?}, v);// After pop: [1, 2]
}append将另一个Vec的内容追加到当前Vec的末尾
fn main() {let mut v1 vec![1, 2];let mut v2 vec![3, 4];v1.append(mut v2);println!(Appended vector: {:?}, v1);// Appended vector: [1, 2, 3, 4]
}drain移除并返回一个范围的元素返回一个迭代器
fn main() {let mut v vec![1, 2, 3, 4];let drained v.drain(1..3);println!(Drained elements: {:?}, drained.collect::Vec_());// Drained elements: [2, 3]println!(After drain: {:?}, v);// After drain: [1, 4]
}clear移除Vec中的所有元素
fn main() {let mut v vec![1, 2, 3];v.clear();println!(Cleared vector: {:?}, v);// Cleared vector: []
}len返回Vec中元素的数量
fn main() {let v vec![1, 2, 3];println!(Length of vector: {}, v.len());// Length of vector: 3
}is_empty判断Vec是否为空
fn main() {let v: Veci32 Vec::new();println!(Is vector empty? {}, v.is_empty());// Is vector empty? truelet v2 vec![1];println!(Is vector empty? {}, v2.is_empty());// Is vector empty? false
}split_off在指定位置将Vec分割成两个部分返回后半部分原向量变为前半部分
fn main() {let mut v vec![1, 2, 3, 4];let second_half v.split_off(2);println!(First half: {:?}, v);// First half: [1, 2]println!(Second half: {:?}, second_half);// Second half: [3, 4]
}resize_with调整Vec的大小为指定大小使用给定的闭包来填充新添加的元素
fn main() {let mut v vec![1, 2];v.resize_with(4, || 0);println!(After resize_with: {:?}, v);// After resize_with: [1, 2, 0, 0]
}leak将Vec的所有权转移到堆上而不进行清理防止向量在超出作用域时被释放。通常用于需要手动管理内存的情况 spare_capacity_mut返回向量当前未使用的容量。通常用于了解向量内部的内存分配情况 resize调整Vec的长度为指定大小如果新长度大于当前长度新添加的元素使用默认值填充
fn main() {let mut v vec![1, 2];v.resize(4, 0);println!(Resized vector: {:?}, v);// Resized vector: [1, 2, 0, 0]
}extend_from_slice从一个切片中扩展Vec将切片中的元素添加到Vec的末尾
fn main() {let mut v vec![1, 2];let slice [3, 4];v.extend_from_slice(slice);println!(Extended vector: {:?}, v);// Extended vector: [1, 2, 3, 4]
}extend_from_within从向量自身的一部分扩展向量
fn main() {let mut v vec![1, 2, 3, 4];v.extend_from_within(1..3);println!(After extend_from_within: {:?}, v);// After extend_from_within: [1, 2, 3, 4, 2, 3]
}into_flattened将包含迭代器的向量转换为一个扁平的迭代器
fn main() {let v vec![vec![1, 2], vec![3, 4]];let flattened v.into_iter().flatten().collect::Vec_();println!(Flattened vector: {:?}, flattened);// Flattened vector: [1, 2, 3, 4]
}dedup删除Vec中连续重复的元素只保留第一个出现的元素
fn main() {let mut v vec![1, 1, 2, 2, 3];v.dedup();println!(Deduped vector: {:?}, v);// Deduped vector: [1, 2, 3]
}splice创建一个拼接迭代器用给定迭代器替换载体中的指定范围并生成删除的项
fn main() {let mut v vec![1, 2, 3, 4];let new [7, 8, 9];let u: Vec_ v.splice(1..3, new).collect();println!({:?}, u);// [2, 3]println!({:?}, v);// [1, 7, 8, 9, 4]
}Deref上的方法
as_flattened将切片中包含的切片扁平化为单个切片
fn main() {let v1 [[1, 2, 3],[4, 5, 6],].as_flattened();println!({:?}, v1);// [1, 2, 3, 4, 5, 6]
}as_flattened_mut将切片中包含的切片扁平化为可变切片
fn main() {fn add_5_to_all(slice: mut [i32]) {for i in slice {*i 5;}}let mut array [[1, 2, 3],[4, 5, 6],[7, 8, 9],];array.as_flattened_mut();add_5_to_all(array.as_flattened_mut());println!({:?}, array);// [[6, 7, 8], [9, 10, 11], [12, 13, 14]]
}is_ascii判断Vec中的所有字符是否都是 ASCII 字符
fn main() {let v vec![1, 2, 3];println!(Is ASCII? {}, v.is_ascii());// Is ASCII? true
}make_ascii_uppercase就地将切片转换为ASCII大写等效项 make_ascii_lowercase就地将切片转换为ASCII小写等效项
fn main() {let mut v vec![97, 98, 65, 66, 200];println!(Original vector: {:?}, v);// Original vector: [97, 98, 65, 66, 200]v.make_ascii_uppercase();println!(After make_ascii_uppercase: {:?}, v);// After make_ascii_uppercase: [65, 66, 65, 66, 200]v.make_ascii_lowercase();println!(After make_ascii_lowercase: {:?}, v);// After make_ascii_lowercase: [97, 98, 97, 98, 200]
}escape_ascii返回一个迭代器该迭代器生成此切片的转义版本 将其视为 ASCII 字符串
fn main() {let s b0\t\r\n\\\\x9d;let escaped s.escape_ascii().to_string();println!({}, escaped);// 0\t\r\n\\\\\x9d
}len返回切片中的元素数
fn main() {let a [1, 2, 3];println!({:?}, a.len());// 3
}is_empty判断切片是否为空
fn main() {let b: [i32] [];println!(Is emoty: {}, b.is_empty());// Is emoty: true
}first返回切片的第一个元素
fn main() {let v [10, 40, 30];println!({}, v.first().unwrap());// 10
}first_mut返回指向slice的第一个元素的可变指针
fn main() {let x mut [0, 1, 2];if let Some(first) x.first_mut() {*first 5;}println!({:?}, x);// [5, 1, 2]
}split_first将Vec分割为第一个元素和剩余部分如果向量为空则返回None
fn main() {let v vec![1, 2, 3];if let Some((first, rest)) v.split_first() {println!(First element: {}, first);// First element: 1println!(Rest: {:?}, rest);// Rest: [2, 3]}
}split_last将Vec分割为最后一个元素和前面的部分如果向量为空则返回None
fn main() {let v vec![1, 2, 3];if let Some((front, last)) v.split_last() {println!(Front: {:?}, front);// Front: 3println!(Last element: {:?}, last);// Last element: [1, 2]}
}get通过索引安全地访问Vec中的元素如果索引超出范围则返回None
fn main() {let v vec![1, 2, 3];if let Some(item) v.get(1) {println!(Element at index 1: {}, item);// Element at index 1: 2}
}get_mut通过索引安全地获取Vec中元素的可变引用如果索引超出范围则返回None
fn main() {let mut v vec![1, 2, 3];if let Some(item) v.get_mut(1) {*item 4;}println!(Modified vector: {:?}, v);// Modified vector: [1, 4, 3]
}get_unchecked返回对元素或子切片的引用不进行边界检查
fn main() {let x [1, 2, 4];unsafe {println!({}, x.get_unchecked(1));// 2}
}get_unchecked_mut返回对元素或子切片的可变引用不执行边界检查
fn main() {let x mut [1, 2, 4];unsafe {let elem x.get_unchecked_mut(1);*elem 13;}println!({:?}, x);// [1, 13, 4]
}swap交换Vec中两个指定索引的元素
fn main() {let mut v vec![1, 2, 3];v.swap(0, 2);println!(Swapped vector: {:?}, v);// Swapped vector: [3, 2, 1]
}reverse反转Vec中元素的顺序
fn main() {let mut v vec![1, 2, 3];v.reverse();println!(Reversed vector: {:?}, v);// Reversed vector: [3, 2, 1]
}iter返回一个不可变的迭代器用于遍历Vec中的元素
fn main() {let v vec![1, 2, 3];for item in v.iter() {println!({}, item);}// 1// 2// 3
}iter_mut返回一个可变的迭代器用于遍历Vec中的元素
fn main() {let mut v vec![1, 2, 3];for item in v.iter_mut() {*item * 2;}println!(Modified vector: {:?}, v);// Modified vector: [2, 4, 6]
}windows返回一个迭代器产生固定大小的窗口切片
fn main() {let v vec![1, 2, 3, 4];for window in v.windows(2) {println!(Window: {:?}, window);}// Window: [1, 2]// Window: [2, 3]// Window: [3, 4]
}chunks将Vec分割成不重叠的子切片每个子切片的大小尽可能接近但不超过指定的大小
fn main() {let v vec![1, 2, 3, 4, 5];for chunk in v.chunks(2) {println!(Chunk: {:?}, chunk);}// Chunk: [1, 2]// Chunk: [3, 4]// Chunk: [5]
}chunks_mut与chunks类似但返回可变的子切片迭代器
fn main() {let mut v vec![1, 2, 3, 4, 5];for chunk in v.chunks_mut(2) {for item in chunk {*item * 2;}}println!(Modified vector with chunks_mut: {:?}, v);// Modified vector with chunks_mut: [2, 4, 6, 8, 10]
}chunks_exact将Vec分割成大小完全为指定大小的不重叠子切片如果向量的长度不是指定大小的整数倍则最后一个子切片可能小于指定大小。如果向量的长度不能被指定大小整除则返回一个空迭代器
fn main() {let v vec![1, 2, 3, 4];for chunk in v.chunks_exact(2) {println!(Exact chunk: {:?}, chunk);}// Exact chunk: [1, 2]// Exact chunk: [3, 4]
}chunks_exact_mut与chunks_exact类似但返回可变的子切片迭代器
fn main() {let mut v vec![1, 2, 3, 4];for chunk in v.chunks_exact_mut(2) {for item in chunk {*item * 2;}}println!(Modified vector with chunks_exact_mut: {:?}, v);// Modified vector with chunks_exact_mut: [2, 4, 6, 8]
}rchunks从向量的末尾开始分割成不重叠的子切片每个子切片的大小尽可能接近但不超过指定的大小
fn main() {let v vec![1, 2, 3, 4, 5];for chunk in v.rchunks(2) {println!(Reverse chunk: {:?}, chunk);}// Reverse chunk: [4, 5]// Reverse chunk: [2, 3]// Reverse chunk: [1]
}rchunks_mut与rchunks类似但返回可变的子切片迭代器
fn main() {let mut v vec![1, 2, 3, 4, 5];for chunk in v.rchunks_mut(2) {for item in chunk {*item * 2;}}println!(Modified vector with rchunks_mut: {:?}, v);// Modified vector with rchunks_mut: [2, 4, 6, 8, 10]
}rchunks_exact从向量的末尾开始分割成大小完全为指定大小的不重叠子切片如果向量的长度不是指定大小的整数倍则最后一个子切片可能小于指定大小。如果向量的长度不能被指定大小整除则返回一个空迭代器
fn main() {let v vec![1, 2, 3, 4, 4, 5];for chunk in v.rchunks_exact(2) {println!(Reverse exact chunk: {:?}, chunk);}
}
// Reverse exact chunk: [4, 5]
// Reverse exact chunk: [3, 4]
// Reverse exact chunk: [1, 2]rchunks_exact_mut与rchunks_exact类似但返回可变的子切片迭代器
fn main() {let mut v vec![1, 2, 3, 4];for chunk in v.rchunks_exact_mut(2) {for item in chunk {*item * 2;}}println!(Modified vector with rchunks_exact_mut: {:?}, v);// Modified vector with rchunks_exact_mut: [2, 4, 6, 8]
}chunk_by根据给定的谓词将Vec分割成不重叠的子切片只要谓词对连续的元素返回相同的值这些元素就会被分到同一个子切片中
fn main() {let v vec![1, 2, 3, 4, 5];let chunks v.chunk_by(|a, b| a % 2 b % 2);for chunk in chunks {println!(Chunk by predicate: {:?}, chunk);}// Chunk by predicate: [1]// Chunk by predicate: [2]// Chunk by predicate: [3]// Chunk by predicate: [4]// Chunk by predicate: [5]
}chunk_by_mut与chunk_by类似但返回可变的子切片迭代器
fn main() {let mut v vec![1, 2, 3, 4, 5];let chunks v.chunk_by_mut(|a, b| a % 2 b % 2);for chunk in chunks {for item in chunk {*item * 2;}}println!(Modified vector with chunk_by_mut: {:?}, v);// Modified vector with chunk_by_mut: [2, 4, 6, 8, 10]
}split_at将Vec在指定位置分割成两个部分返回一个包含两个切片的元组
fn main() {let v vec![1, 2, 3, 4, 5];let (left, right) v.split_at(2);println!(Left: {:?}, left);// Left: [1, 2]println!(Right: {:?}, right);// Right: [3, 4, 5]
}split_at_mut与split_at类似但返回可变的两个切片
fn main() {let mut v vec![1, 2, 3, 4, 5];let (left, right) v.split_at_mut(2);for item in left.iter_mut() {*item * 2;}println!(Modified left and right: {:?}, {:?}, left, right);// Modified left and right: [2, 4], [3, 4, 5]
}split_at_unchecked通过索引不安全地将Vec在指定位置分割成两个部分不进行边界检查。这是一个危险的操作可能导致未定义行为如果索引超出范围
fn main() {let v vec![1, 2, 3, 4, 5];let (left, right) unsafe { v.split_at_unchecked(2) };println!(Unchecked split left: {:?}, left);// Unchecked split left: [1, 2]println!(Unchecked split right: {:?}, right);// Unchecked split right: [3, 4, 5]
}split_at_mut_unchecked与split_at_unchecked类似但返回可变的两个切片。同样是危险的操作不进行边界检查
fn main() {let mut v vec![1, 2, 3, 4, 5];let (left, right) unsafe { v.split_at_mut_unchecked(2) };for item in left.iter_mut() {*item * 2;}println!(Modified unchecked left and right: {:?}, {:?}, left, right);// Modified unchecked left and right: [2, 4], [3, 4, 5]
}split_at_checked通过索引安全地将Vec在指定位置分割成两个部分如果索引超出范围则返回None
fn main() {let v vec![1, 2, 3, 4, 5];if let Some((left, right)) v.split_at_checked(2) {println!(Checked split left: {:?}, left);// Checked split left: [1, 2]println!(Checked split right: {:?}, right);// Checked split right: [3, 4, 5]}
}split_at_mut_checked与split_at_checked类似但返回可变的两个切片。如果索引超出范围则返回None
fn main() {let mut v vec![1, 2, 3, 4, 5];if let Some((left, right)) v.split_at_mut_checked(2) {for item in left.iter_mut() {*item * 2;}println!(Modified checked left and right: {:?}, {:?}, left, right);// Modified checked left and right: [2, 4], [3, 4, 5]}
}split根据给定的值将Vec分割成多个子切片返回一个迭代器
fn main() {let v vec![1, 2, 3, 4, 5];let splits v.split(|x| x 3);for split in splits {println!(Split: {:?}, split);}// Split: [1, 2]// Split: [4, 5]
}split_mut与split类似但返回可变的子切片迭代器
fn main() {let mut v vec![1, 2, 3, 4, 5];let splits v.split_mut(|x| x 3);for split in splits {for item in split {*item * 2;}}println!(Modified vector with split_mut: {:?}, v);// Modified vector with split_mut: [2, 4, 3, 8, 10]
}split_inclusive根据给定的值将Vec分割成多个子切片包括分割值在子切片中返回一个迭代器
fn main() {let v vec![1, 2, 3, 4, 5];let splits v.split_inclusive(|x| x 3);for split in splits {println!(Inclusive split: {:?}, split);}// Inclusive split: [1, 2, 3]// Inclusive split: [4, 5]
}split_inclusive_mut与split_inclusive类似但返回可变的子切片迭代器
fn main() {let mut v vec![1, 2, 3, 4, 5];let splits v.split_inclusive_mut(|x| x 3);for split in splits {for item in split {*item * 2;}}println!(Modified vector with split_inclusive_mut: {:?}, v);// Modified vector with split_inclusive_mut: [2, 4, 6, 8, 10]
}rsplit从向量的末尾开始根据给定的值将Vec分割成多个子切片返回一个迭代器
fn main() {let v vec![1, 2, 3, 4, 5];let splits v.rsplit(|x| x 3);for split in splits {println!(Reverse split: {:?}, split);}// Reverse split: [4, 5]// Reverse split: [1, 2]
}rsplit_mut与rsplit类似但返回可变的子切片迭代器
fn main() {let mut v vec![1, 2, 3, 4, 5];let splits v.rsplit_mut(|x| x 3);for split in splits {for item in split {*item * 2;}}println!(Modified vector with rsplit_mut: {:?}, v);// Modified vector with rsplit_mut: [2, 4, 3, 8, 10]
}splitn将Vec分割成指定数量的子切片返回一个迭代器
fn main() {let v vec![1, 2, 3, 4, 5];let splits v.splitn(3, |x| x % 2 0);for split in splits {println!(Splitn: {:?}, split);}// Splitn: [1]// Splitn: [3]// Splitn: [5]
}splitn_mut与splitn类似但返回可变的子切片迭代器
fn main() {let mut v vec![1, 2, 3, 4, 5];let splits v.splitn_mut(3, |x| x % 2 0);for split in splits {for item in split {*item * 2;}}println!(Modified vector with splitn_mut: {:?}, v);// Modified vector with splitn_mut: [2, 2, 6, 4, 10]
}rsplitn从向量的末尾开始将Vec分割成指定数量的子切片返回一个迭代器
fn main() {let v vec![1, 2, 3, 4, 5];let splits v.rsplitn(3, |x| x % 2 0);for split in splits {println!(Reverse splitn: {:?}, split);}// Reverse splitn: [5]// Reverse splitn: [3]// Reverse splitn: [1]
}rsplitn_mut与rsplitn类似但返回可变的子切片迭代器
fn main() {let mut v vec![1, 2, 3, 4, 5];let splits v.rsplitn_mut(3, |x| x % 2 0);for split in splits {for item in split {*item * 2;}}println!(Modified vector with rsplitn_mut: {:?}, v);// Modified vector with rsplitn_mut: [2, 2, 6, 4, 10]
}contains判断Vec中是否包含指定元素
fn main() {let v vec![1, 2, 3];println!(Contains 2? {}, v.contains(2));// Contains 2? true
}starts_with判断Vec是否以指定的切片开头
fn main() {let v vec![1, 2, 3, 4, 5];let slice [1, 2];println!(Starts with slice? {}, v.starts_with(slice));// Starts with slice? true
}ends_with判断Vec是否以指定的切片结尾
fn main() {let v vec![1, 2, 3, 4, 5];let slice [4, 5];println!(Ends with slice? {}, v.ends_with(slice));// Ends with slice? true
}strip_prefix如果Vec以指定的切片开头则移除该切片并返回Some包含剩余部分否则返回None
fn main() {let v vec![1, 2, 3, 4, 5];if let Some(stripped) v.strip_prefix([1, 2]) {println!(Stripped vector: {:?}, stripped);}// Stripped vector: [3, 4, 5]
}strip_suffix如果Vec以指定的切片结尾则移除该切片并返回Some包含剩余部分否则返回None
fn main() {let v vec![1, 2, 3, 4, 5];if let Some(stripped) v.strip_suffix([4, 5]) {println!(Stripped vector: {:?}, stripped);// Stripped vector: [1, 2, 3]}
}binary_search在已排序的Vec中进行二分查找返回一个Result类型表示查找结果。如果找到元素返回Ok(index)其中index是元素在向量中的位置如果未找到返回Err(index)其中index是元素应该插入的位置以保持向量有序
fn main() {let v vec![1, 2, 3, 4, 5];let result v.binary_search(3);match result {Ok(index) println!(Found at index {}, index),// Found at index 2Err(index) println!(Not found, would be inserted at index {}, index),}
}binary_search_by使用自定义的比较函数在已排序的Vec中进行二分查找
fn main() {let v vec![1, 2, 3, 4, 5];let result v.binary_search_by(|x| x.cmp(3));match result {Ok(index) println!(Found at index {}, index),// Found at index 2Err(index) println!(Not found, would be inserted at index {}, index),}
}binary_search_by_key使用自定义的键提取函数和比较函数在已排序的Vec中进行二分查找
fn main() {let v vec![(1, a), (2, b), (3, c)];let result v.binary_search_by_key(2, |(k, _)| k);match result {Ok(index) println!(Found at index {}, index),// Found at index 1Err(index) println!(Not found, would be inserted at index {}, index),}
}sort_unstable对Vec中的元素进行不稳定排序。不稳定排序可能会改变相等元素的相对顺序
fn main() {let mut v vec![3, 1, 2];v.sort_unstable();println!(Unstable sorted vector: {:?}, v);// Unstable sorted vector: [1, 2, 3]
}sort_unstable_by使用自定义的比较函数对Vec中的元素进行不稳定排序
fn main() {let mut v vec![(3, c), (1, a), (2, b)];v.sort_unstable_by(|a, b| a.0.cmp(b.0));println!(Unstable sorted by key vector: {:?}, v);// Unstable sorted by key vector: [(1, a), (2, b), (3, c)]
}sort_unstable_by_key使用自定义的键提取函数对Vec中的元素进行不稳定排序
fn main() {let mut v vec![(3, c), (1, a), (2, b)];v.sort_unstable_by_key(|(k, _)| k);println!(Unstable sorted by extracted key vector: {:?}, v);// Unstable sorted by extracted key vector: [(1, a), (2, b), (3, c)]
}select_nth_unstable在Vec中选择第 n 小的元素并将其移动到正确的位置同时将小于它的元素移动到左边大于它的元素移动到右边但不保证相对顺序 select_nth_unstable_by使用自定义的比较函数在Vec中选择第 n 小的元素并进行不稳定排序 select_nth_unstable_by_key使用自定义的键提取函数在Vec中选择第 n 小的元素并进行不稳定排序 rotate_left将Vec向左旋转指定的步数
fn main() {let mut v vec![1, 2, 3, 4, 5];v.rotate_left(2);println!(Rotated left vector: {:?}, v);// Rotated left vector: [3, 4, 5, 1, 2]
}rotate_right将Vec向右旋转指定的步数
fn main() {let mut v vec![1, 2, 3, 4, 5];v.rotate_right(2);println!(Rotated right vector: {:?}, v);// Rotated right vector: [4, 5, 1, 2, 3]
}fill用指定的值填充整个Vec
fn main() {let mut v vec![1, 2, 3];v.fill(4);println!(Filled vector: {:?}, v);// Filled vector: [4, 4, 4]
}fill_with使用一个闭包生成的值填充整个Vec
fn main() {let mut v vec![1, 2, 3];v.fill_with(|| 5);println!(Filled with closure vector: {:?}, v);// Filled with closure vector: [5, 5, 5]
}clone_from_slice从一个切片克隆元素到Vec中替换Vec的现有内容
fn main() {let mut v vec![5, 6];let slice [7, 8];v.clone_from_slice(slice);println!(Cloned vector: {:?}, v);// Cloned vector: [7, 8]
}copy_from_slice从一个切片复制元素到Vec中从Vec的特定位置开始覆盖切片长度和Vec长度必须一样
fn main() {let mut v vec![1, 2];let slice [5, 6];v.copy_from_slice(slice);println!(Copied vector: {:?}, v);// Copied vector: [5, 6]
}copy_within将元素从切片的一部分复制到自身的另一部分
fn main() {let mut bytes *bHello, World!;bytes.copy_within(1..5, 8);assert_eq!(bytes, bHello, Wello!);
}swap_with_slice将切片与另一个切片交换内容
fn main() {let mut slice1 [0, 0];let mut slice2 [1, 2, 3, 4];slice1.swap_with_slice(mut slice2[2..]);println!(slice1:{:?}, slice1);// slice1:[3, 4]println!(slice2:{:?}, slice2);// slice2:[1, 2, 0, 0]
}partition_point在已排序的Vec中找到满足特定谓词的分割点。即返回一个索引使得在该索引之前的元素满足谓词在该索引之后的元素不满足谓词
fn main() {let v vec![1, 2, 3, 4, 5];let partition v.partition_point(|x| x 3);println!(Partition point: {}, partition);// Partition point: 2
}sort对Vec中的元素进行排序
fn main() {let mut v vec![3, 1, 2];v.sort();println!(Sorted vector: {:?}, v);// Sorted vector: [1, 2, 3]
}sort_by使用自定义的比较函数对Vec中的元素进行稳定排序
fn main() {let mut v vec![(3, c), (1, a), (2, b)];v.sort_by(|a, b| a.0.cmp(b.0));println!(Sorted by key vector: {:?}, v);// Sorted by key vector: [(1, a), (2, b), (3, c)]
}sort_by_key使用自定义的键提取函数对Vec中的元素进行稳定排序
fn main() {let mut v vec![(3, c), (1, a), (2, b)];v.sort_by_key(|(k, _)| k);println!(Sorted by extracted key vector: {:?}, v);// Sorted by extracted key vector: [(1, a), (2, b), (3, c)]
}sort_by_cached_key使用自定义的键提取函数对Vec中的元素进行稳定排序并缓存键以提高性能
fn main() {let mut v vec![(3, c), (1, a), (2, b)];v.sort_by_cached_key(|(k, _)| k);println!(Sorted by cached key vector: {:?}, v);// Sorted by cached key vector: [(1, a), (2, b), (3, c)]
}to_vec将一个可转换为向量的类型转换为Vec。通常用于将迭代器、切片等转换为向量
fn main() {let slice [1, 2, 3];let v slice.to_vec();println!(Converted to vector: {:?}, v);// Converted to vector: [1, 2, 3]
}repeat创建一个包含重复元素的迭代器。可以与其他方法结合使用如collect来创建一个包含重复元素的Vec
fn main() {let repeated (0..5).map(|_| 1).collect::Vec_();println!(Repeated vector: {:?}, repeated);// Repeated vector: [1, 1, 1, 1, 1]
}concat连接多个切片或展平为单个值
fn main() {let s [hello, world].concat();println!({}, s);// helloworld
}join将向量中的元素用指定的分隔符连接成一个字符串
fn main() {let v vec![a, b, c];let joined v.join(,);println!(Joined string: {}, joined);// Joined string: a,b,c
}to_ascii_uppercase将Vec中的所有 ASCII 字符转换为大写。用于将向量中的 ASCII 字符转换为大写形式 to_ascii_lowercase将Vec中的所有 ASCII 字符转换为小写。前面也有提及用于将向量中的 ASCII 字符转换为小写形式
fn main() {let original vec![97, 98, 65, 66, 200];let uppercase_result original.to_ascii_uppercase();println!(Uppercase result: {:?}, uppercase_result);// Uppercase result: [65, 66, 65, 66, 200]let lowercase_result original.to_ascii_lowercase();println!(Lowercase result: {:?}, lowercase_result);// Lowercase result: [97, 98, 97, 98, 200]
}
