查看本地官方文檔

安裝rust后運(yùn)行

rustup doc

查看The Standard Library即可獲取標(biāo)準(zhǔn)庫(kù)內(nèi)容

std::vec::Vec定義

Vec除了可以作為動(dòng)態(tài)數(shù)組還可以模擬為一個(gè)棧，僅使用push、pop即可

Vec默認(rèn)分配在堆上，對(duì)于一個(gè)容量為4，有兩個(gè)元素a、b的向量?jī)?nèi)存布局如下

            ptr      len  capacity+--------+--------+--------+| 0x0123 |      2 |      4 |+--------+--------+--------+|v
Heap   +--------+--------+--------+--------+|    'a' |    'b' | uninit | uninit |+--------+--------+--------+--------+

Vec定義

pub struct Vec<T, A: Allocator = Global> {// 存儲(chǔ)了動(dòng)態(tài)數(shù)組的元素?cái)?shù)據(jù)，并且根據(jù)需要可以動(dòng)態(tài)地增長(zhǎng)或收縮以容納更多或更少的元素buf: RawVec<T, A>,// 表示當(dāng)前Vec中實(shí)際存儲(chǔ)的元素?cái)?shù)量len: usize,
}

RawVec：定義

pub(crate) struct RawVec<T, A: Allocator = Global> {// 這是一個(gè)Unique<T>類型的指針，指向分配的內(nèi)存塊中存儲(chǔ)元素的起始位置。這個(gè)指針用于訪問和操作存儲(chǔ)在RawVec中的元素ptr: Unique<T>,// 代表RawVec的容量，容量通常會(huì)隨著元素的添加而動(dòng)態(tài)調(diào)整，當(dāng)需要更多空間時(shí)，會(huì)進(jìn)行內(nèi)存重新分配以增加容量。同時(shí)，對(duì)于零大小類型（ZST），容量的處理方式有所不同，capacity()方法會(huì)在這種情況下返回usize::MAXcap: Cap,// 分配器負(fù)責(zé)分配和釋放內(nèi)存，以及管理內(nèi)存的生命周期，通過這個(gè)分配器，RawVec可以根據(jù)需要?jiǎng)討B(tài)地分配和調(diào)整內(nèi)存空間來存儲(chǔ)元素alloc: A,
}

每次進(jìn)行自動(dòng)分配容量的開銷比預(yù)先分配容量大得多，所以預(yù)先分配容量可以減少分配的開銷，建議使用with_capacity預(yù)先分配容量

方法

with_capacity：創(chuàng)建一個(gè)具有指定初始容量的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：從給定的原始指針和長(zhǎng)度創(chuàng)建一個(gè)Vec，使用時(shí)需要非常小心，確保內(nèi)存管理正確

• ptr必須使用全局分配器進(jìn)行分配，例如通過alloc::alloc函數(shù)
• T需要和ptr的對(duì)齊方式相同。（不那么嚴(yán)格的對(duì)齊是不夠的，對(duì)齊確實(shí)需要相等才能滿足dealloc要求，即內(nèi)存必須以相同的布局分配和釋放。）
• T的大小乘以容量（即分配的大小（以字節(jié)為單位）需要與指針分配的大小相同。（因?yàn)榕c對(duì)齊類似，必須以相同的布局大小調(diào)用dealloc。）
• Length必須小于或等于capacity容量
• 第一個(gè)Length值必須正確初始化T類型的值
• 容量需要是指針分配的容量
• 分配的字節(jié)大小必須不大于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 {// 覆蓋內(nèi)存for i in 0..len {ptr::write(p.add(i), 4 + i);}// 將內(nèi)存重新構(gòu)建為Veclet rebuilt = Vec::from_raw_parts(p, len, cap);println!("{:?}", rebuilt);// [4, 5, 6]}
}

capacity：返回Vec的當(dāng)前容量

fn main() {let mut v = Vec::with_capacity(5);v.push(1);v.push(2);println!("Capacity: {}", v.capacity()); // 輸出初始容量 5，目前只使用了部分容量// Capacity: 5
}

reserve：增加Vec的容量，確保至少可以容納指定數(shù)量的更多元素

fn main() {let mut v: Vec<i32> = Vec::new();v.reserve(10);println!("Capacity after reserve: {}", v.capacity());// Capacity after reserve: 10
}

reserve_exact：精確地將Vec的容量調(diào)整為指定值，容量為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: Vec<i32> = Vec::new();if v.try_reserve(1).is_ok() {println!("Reserved successfully");// Reserved successfully} else {println!("Failed to reserve");}
}

try_reserve_exact：嘗試將Vec的容量精確調(diào)整為指定值，如果無法調(diào)整則返回false

fn main() {let mut v: Vec<i32> = 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的容量調(diào)整為與當(dāng)前長(zhǎng)度相等，釋放多余的內(nèi)存

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的容量縮小為指定最小容量，釋放多余的內(nèi)存

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轉(zhuǎn)換為Box<[T]>，所有權(quán)轉(zhuǎn)移

fn main() {let v = vec![1, 2, 3];let boxed_slice = v.into_boxed_slice();println!("{}", boxed_slice[0]);// 1
}

truncate：截?cái)?code>Vec，使其長(zhǎng)度不超過指定值

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：返回指向向量緩沖區(qū)的原始指針或懸空的原始指針

fn main() {let x = vec![1, 2, 4];let x_ptr = x.as_ptr();unsafe {for i in 0..x.len() {// 將指針加i即右移i位，然后解引用，得到對(duì)應(yīng)位置的元素1，2，4// 1按位左移相當(dāng)于*2assert_eq!(*x_ptr.add(i), 1 << i);}}
}

as_mut_ptr：返回指向Vec緩沖區(qū)的不安全可變指針，或懸空的指針

fn main() {let size = 4;let mut x: Vec<i32> = Vec::with_capacity(size);let x_ptr = x.as_mut_ptr();// 初始化原始指針并設(shè)置長(zhǎng)度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：低級(jí)操作，用于修改向量長(zhǎng)度

• new_len必須小于或等于?capacity()
• 必須初始化元素

fn main() {let size = 4;let mut x: Vec<i32> = Vec::with_capacity(size);let x_ptr = x.as_mut_ptr();// 初始化原始指針并設(shè)置長(zhǎng)度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中刪除一個(gè)元素并返回它，被刪除的元素位置將被Vec的最后一個(gè)元素替換，不保留其余元素的順序，如果需要保留元素順序請(qǐng)使用remove

fn main() {let mut v = vec!["foo", "bar", "baz", "qux"];let _ = v.swap_remove(1);println!("{:?}", v);// ["foo", "qux", "baz"]
}

insert：在指定位置插入一個(gè)元素

fn main() {let mut v = vec![1, 2, 3];v.insert(1, 4);println!("Inserted vector: {:?}", v);// Inserted vector: [1, 4, 2, 3]
}

remove：移除指定位置的元素并返回它，同時(shí)調(diào)整向量的長(zhǎng)度

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：根據(jù)自定義的鍵提取函數(shù)去除連續(xù)重復(fù)的元素

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：使用自定義的比較函數(shù)去除連續(xù)重復(fù)的元素

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的末尾添加一個(gè)元素

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：將另一個(gè)Vec的內(nèi)容追加到當(dāng)前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：移除并返回一個(gè)范圍的元素，返回一個(gè)迭代器

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中元素的數(shù)量

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: Vec<i32> = 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分割成兩個(gè)部分，返回后半部分，原向量變?yōu)榍鞍氩糠?/p>

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：調(diào)整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的所有權(quán)轉(zhuǎn)移到堆上而不進(jìn)行清理，防止向量在超出作用域時(shí)被釋放。通常用于需要手動(dòng)管理內(nèi)存的情況

spare_capacity_mut：返回向量當(dāng)前未使用的容量。通常用于了解向量?jī)?nèi)部的內(nèi)存分配情況

resize：調(diào)整Vec的長(zhǎng)度為指定大小，如果新長(zhǎng)度大于當(dāng)前長(zhǎng)度，新添加的元素使用默認(rèn)值填充

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：從一個(gè)切片中擴(kuò)展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：從向量自身的一部分?jǐn)U展向量

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：將包含迭代器的向量轉(zhuǎn)換為一個(gè)扁平的迭代器

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中連續(xù)重復(fù)的元素，只保留第一個(gè)出現(xiàn)的元素

fn main() {let mut v = vec![1, 1, 2, 2, 3];v.dedup();println!("Deduped vector: {:?}", v);// Deduped vector: [1, 2, 3]
}

splice：創(chuàng)建一個(gè)拼接迭代器，用給定迭代器替換載體中的指定范圍，并生成刪除的項(xiàng)

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：將切片中包含的切片扁平化為單個(gè)切片

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：就地將切片轉(zhuǎn)換為ASCII大寫等效項(xiàng)
make_ascii_lowercase：就地將切片轉(zhuǎn)換為ASCII小寫等效項(xiàng)

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：返回一個(gè)迭代器，該迭代器生成此切片的轉(zhuǎn)義版本， 將其視為 ASCII 字符串

fn main() {let s = b"0\t\r\n'\"\\\x9d";let escaped = s.escape_ascii().to_string();println!("{}", escaped);// 0\t\r\n\'\"\\\x9d
}

len：返回切片中的元素?cái)?shù)

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：返回切片的第一個(gè)元素

fn main() {let v = [10, 40, 30];println!("{}", v.first().unwrap());// 10
}

first_mut：返回指向slice的第一個(gè)元素的可變指針

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分割為第一個(gè)元素和剩余部分，如果向量為空，則返回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分割為最后一個(gè)元素和前面的部分，如果向量為空，則返回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：返回對(duì)元素或子切片的引用，不進(jìn)行邊界檢查

fn main() {let x = &[1, 2, 4];unsafe {println!("{}", x.get_unchecked(1));// 2}
}

get_unchecked_mut：返回對(duì)元素或子切片的可變引用，不執(zhí)行邊界檢查

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中兩個(gè)指定索引的元素

fn main() {let mut v = vec![1, 2, 3];v.swap(0, 2);println!("Swapped vector: {:?}", v);// Swapped vector: [3, 2, 1]
}

reverse：反轉(zhuǎn)Vec中元素的順序

fn main() {let mut v = vec![1, 2, 3];v.reverse();println!("Reversed vector: {:?}", v);// Reversed vector: [3, 2, 1]
}

iter：返回一個(gè)不可變的迭代器，用于遍歷Vec中的元素

fn main() {let v = vec![1, 2, 3];for item in v.iter() {println!("{}", item);}// 1// 2// 3
}

iter_mut：返回一個(gè)可變的迭代器，用于遍歷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：返回一個(gè)迭代器，產(chǎn)生固定大小的窗口切片

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分割成不重疊的子切片，每個(gè)子切片的大小盡可能接近但不超過指定的大小

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分割成大小完全為指定大小的不重疊子切片，如果向量的長(zhǎng)度不是指定大小的整數(shù)倍，則最后一個(gè)子切片可能小于指定大小。如果向量的長(zhǎng)度不能被指定大小整除，則返回一個(gè)空迭代器

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：從向量的末尾開始分割成不重疊的子切片，每個(gè)子切片的大小盡可能接近但不超過指定的大小

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：從向量的末尾開始分割成大小完全為指定大小的不重疊子切片，如果向量的長(zhǎng)度不是指定大小的整數(shù)倍，則最后一個(gè)子切片可能小于指定大小。如果向量的長(zhǎng)度不能被指定大小整除，則返回一個(gè)空迭代器

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：根據(jù)給定的謂詞將Vec分割成不重疊的子切片，只要謂詞對(duì)連續(xù)的元素返回相同的值，這些元素就會(huì)被分到同一個(gè)子切片中

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在指定位置分割成兩個(gè)部分，返回一個(gè)包含兩個(gè)切片的元組

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類似，但返回可變的兩個(gè)切片

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在指定位置分割成兩個(gè)部分，不進(jìn)行邊界檢查。這是一個(gè)危險(xiǎn)的操作，可能導(dǎo)致未定義行為如果索引超出范圍

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類似，但返回可變的兩個(gè)切片。同樣是危險(xiǎn)的操作，不進(jìn)行邊界檢查

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在指定位置分割成兩個(gè)部分，如果索引超出范圍則返回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類似，但返回可變的兩個(gè)切片。如果索引超出范圍則返回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：根據(jù)給定的值將Vec分割成多個(gè)子切片，返回一個(gè)迭代器

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：根據(jù)給定的值將Vec分割成多個(gè)子切片，包括分割值在子切片中，返回一個(gè)迭代器

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：從向量的末尾開始根據(jù)給定的值將Vec分割成多個(gè)子切片，返回一個(gè)迭代器

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分割成指定數(shù)量的子切片，返回一個(gè)迭代器

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分割成指定數(shù)量的子切片，返回一個(gè)迭代器

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是否以指定的切片結(jié)尾

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以指定的切片結(jié)尾，則移除該切片并返回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中進(jìn)行二分查找，返回一個(gè)Result類型，表示查找結(jié)果。如果找到元素，返回Ok(index)，其中index是元素在向量中的位置；如果未找到，返回Err(index)，其中index是元素應(yīng)該插入的位置以保持向量有序

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：使用自定義的比較函數(shù)在已排序的Vec中進(jìn)行二分查找

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：使用自定義的鍵提取函數(shù)和比較函數(shù)在已排序的Vec中進(jìn)行二分查找

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：對(duì)Vec中的元素進(jìn)行不穩(wěn)定排序。不穩(wěn)定排序可能會(huì)改變相等元素的相對(duì)順序

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：使用自定義的比較函數(shù)對(duì)Vec中的元素進(jìn)行不穩(wěn)定排序

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：使用自定義的鍵提取函數(shù)對(duì)Vec中的元素進(jìn)行不穩(wěn)定排序

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 小的元素，并將其移動(dòng)到正確的位置，同時(shí)將小于它的元素移動(dòng)到左邊，大于它的元素移動(dòng)到右邊，但不保證相對(duì)順序

select_nth_unstable_by：使用自定義的比較函數(shù)在Vec中選擇第 n 小的元素，并進(jìn)行不穩(wěn)定排序

select_nth_unstable_by_key：使用自定義的鍵提取函數(shù)在Vec中選擇第 n 小的元素，并進(jìn)行不穩(wěn)定排序

rotate_left：將Vec向左旋轉(zhuǎn)指定的步數(shù)

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向右旋轉(zhuǎn)指定的步數(shù)

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：用指定的值填充整個(gè)Vec

fn main() {let mut v = vec![1, 2, 3];v.fill(4);println!("Filled vector: {:?}", v);// Filled vector: [4, 4, 4]
}

fill_with：使用一個(gè)閉包生成的值填充整個(gè)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：從一個(gè)切片克隆元素到Vec中，替換Vec的現(xiàn)有內(nèi)容

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：從一個(gè)切片復(fù)制元素到Vec中，從Vec的特定位置開始覆蓋，切片長(zhǎng)度和Vec長(zhǎng)度必須一樣

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：將元素從切片的一部分復(fù)制到自身的另一部分

fn main() {let mut bytes = *b"Hello, World!";bytes.copy_within(1..5, 8);assert_eq!(&bytes, b"Hello, Wello!");
}

swap_with_slice：將切片與另一個(gè)切片交換內(nèi)容

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中找到滿足特定謂詞的分割點(diǎn)。即返回一個(gè)索引，使得在該索引之前的元素滿足謂詞，在該索引之后的元素不滿足謂詞

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：對(duì)Vec中的元素進(jìn)行排序

fn main() {let mut v = vec![3, 1, 2];v.sort();println!("Sorted vector: {:?}", v);// Sorted vector: [1, 2, 3]
}

sort_by：使用自定義的比較函數(shù)對(duì)Vec中的元素進(jìn)行穩(wěn)定排序

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：使用自定義的鍵提取函數(shù)對(duì)Vec中的元素進(jìn)行穩(wěn)定排序

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：使用自定義的鍵提取函數(shù)對(duì)Vec中的元素進(jìn)行穩(wěn)定排序，并緩存鍵以提高性能

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：將一個(gè)可轉(zhuǎn)換為向量的類型轉(zhuǎn)換為Vec。通常用于將迭代器、切片等轉(zhuǎn)換為向量

fn main() {let slice = &[1, 2, 3];let v = slice.to_vec();println!("Converted to vector: {:?}", v);// Converted to vector: [1, 2, 3]
}

repeat：創(chuàng)建一個(gè)包含重復(fù)元素的迭代器?？梢耘c其他方法結(jié)合使用，如collect來創(chuàng)建一個(gè)包含重復(fù)元素的Vec

fn main() {let repeated = (0..5).map(|_| 1).collect::<Vec<_>>();println!("Repeated vector: {:?}", repeated);// Repeated vector: [1, 1, 1, 1, 1]
}

concat：連接多個(gè)切片或展平為單個(gè)值

fn main() {let s = ["hello", "world"].concat();println!("{}", s);// helloworld
}

join：將向量中的元素用指定的分隔符連接成一個(gè)字符串

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 字符轉(zhuǎn)換為大寫。用于將向量中的 ASCII 字符轉(zhuǎn)換為大寫形式
to_ascii_lowercase：將Vec中的所有 ASCII 字符轉(zhuǎn)換為小寫。前面也有提及，用于將向量中的 ASCII 字符轉(zhuǎn)換為小寫形式

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]
}