Rust std::vec::Vec＜T＞动态数组：所有相关 API 全面介绍

Rust std::vec::Vec动态数组：所有相关 API 全面介绍

• [一、 API 全面介绍](#一、 API 全面介绍)
• • [1. 引言](#1. 引言)
  • [2. 构造 Vec](#2. 构造 Vec)
  • • [2.1 空 Vec](#2.1 空 Vec)
    • [2.2 带初始容量的空 Vec](#2.2 带初始容量的空 Vec)
    • [2.3 宏 vec!](#2.3 宏 vec!)
    • [2.4 从迭代器构建](#2.4 从迭代器构建)
    • [2.5 从数组/切片转换](#2.5 从数组/切片转换)
    • [2.6 从其他类型转换](#2.6 从其他类型转换)
  • [3. 访问元素](#3. 访问元素)
  • • [3.1 索引访问](#3.1 索引访问)
    • [3.2 get / get_mut（安全访问）](#3.2 get / get_mut（安全访问）)
    • [3.3 first / last 及其可变版本](#3.3 first / last 及其可变版本)
    • [3.4 first_chunk / last_chunk（一次取多个）](#3.4 first_chunk / last_chunk（一次取多个）)
  • [4. 添加元素](#4. 添加元素)
  • • [4.1 push（尾部追加）](#4.1 push（尾部追加）)
    • [4.2 insert（指定位置插入）](#4.2 insert（指定位置插入）)
    • [4.3 extend / extend_from_slice（批量追加）](#4.3 extend / extend_from_slice（批量追加）)
    • [4.4 append（拼接并清空源 Vec）](#4.4 append（拼接并清空源 Vec）)
    • [4.5 resize / resize_with（调整长度）](#4.5 resize / resize_with（调整长度）)
  • [5. 删除元素](#5. 删除元素)
  • • [5.1 pop（弹出尾部）](#5.1 pop（弹出尾部）)
    • [5.2 remove（按索引删除并返回）](#5.2 remove（按索引删除并返回）)
    • [5.3 swap_remove（交换后删除，O(1)）](#5.3 swap_remove（交换后删除，O(1)）)
    • [5.4 truncate（截断到指定长度）](#5.4 truncate（截断到指定长度）)
    • [5.5 clear（清空所有元素）](#5.5 clear（清空所有元素）)
    • [5.6 retain / retain_mut（按条件保留）](#5.6 retain / retain_mut（按条件保留）)
    • [5.7 dedup / dedup_by / dedup_by_key（去重）](#5.7 dedup / dedup_by / dedup_by_key（去重）)
    • [5.8 drain（范围删除并返回迭代器）](#5.8 drain（范围删除并返回迭代器）)
    • [5.9 split_off（从指定位置切分）](#5.9 split_off（从指定位置切分）)
  • [6. 容量与内存管理](#6. 容量与内存管理)
  • • [6.1 len / is_empty](#6.1 len / is_empty)
    • [6.2 capacity（当前容量）](#6.2 capacity（当前容量）)
    • [6.3 reserve / reserve_exact（预留容量）](#6.3 reserve / reserve_exact（预留容量）)
    • [6.4 shrink_to_fit / shrink_to（收缩容量）](#6.4 shrink_to_fit / shrink_to（收缩容量）)
    • [6.5 into_boxed_slice（转为 Box<T>）](#6.5 into_boxed_slice（转为 Box<[T]>）)
    • [6.6 leak（泄漏内存，返回 &'static mut T）](#6.6 leak（泄漏内存，返回 &'static mut [T]）)
  • [7. 切片与视图](#7. 切片与视图)
  • • [7.1 as_slice / as_mut_slice](#7.1 as_slice / as_mut_slice)
    • [7.2 切片操作](#7.2 切片操作)
  • [8. 迭代与遍历](#8. 迭代与遍历)
  • • [8.1 不可变迭代](#8.1 不可变迭代)
    • [8.2 可变迭代](#8.2 可变迭代)
    • [8.3 消费迭代（into_iter）](#8.3 消费迭代（into_iter）)
    • [8.4 带索引迭代](#8.4 带索引迭代)
    • [8.5 iter / iter_mut](#8.5 iter / iter_mut)
    • [8.6 windows / chunks / split](#8.6 windows / chunks / split)
  • [9. 查找与判断](#9. 查找与判断)
  • • [9.1 contains](#9.1 contains)
    • [9.2 starts_with / ends_with](#9.2 starts_with / ends_with)
    • [9.3 binary_search 系列（要求有序）](#9.3 binary_search 系列（要求有序）)
    • [9.4 partition_point（有序数组的分界点）](#9.4 partition_point（有序数组的分界点）)
  • [10. 排序与反转](#10. 排序与反转)
  • • [10.1 sort / sort_unstable](#10.1 sort / sort_unstable)
    • [10.2 sort_by / sort_by_key](#10.2 sort_by / sort_by_key)
    • [10.3 reverse](#10.3 reverse)
    • [10.4 rotate_left / rotate_right](#10.4 rotate_left / rotate_right)
  • [11. 聚合与统计](#11. 聚合与统计)
  • • [11.1 求和 / 求积](#11.1 求和 / 求积)
    • [11.2 最大值 / 最小值](#11.2 最大值 / 最小值)
    • [11.3 平均值](#11.3 平均值)
  • [12. 转换与扁平化](#12. 转换与扁平化)
  • • [12.1 into_iter + collect（类型转换）](#12.1 into_iter + collect（类型转换）)
    • [12.2 concat / join（拼接）](#12.2 concat / join（拼接）)
    • [12.3 flatten（扁平化嵌套迭代器）](#12.3 flatten（扁平化嵌套迭代器）)
    • [12.4 转 String](#12.4 转 String)
  • [13. 比较与相等](#13. 比较与相等)
  • • [13.1 相等比较](#13.1 相等比较)
    • [13.2 与切片比较](#13.2 与切片比较)
  • [14. 内存与安全](#14. 内存与安全)
  • • [14.1 内存布局](#14.1 内存布局)
    • [14.2 借用规则](#14.2 借用规则)
    • [14.3 越界安全](#14.3 越界安全)
  • [15. 综合示例](#15. 综合示例)
  • • [15.1 统计词频](#15.1 统计词频)
    • [15.2 去重并保持顺序](#15.2 去重并保持顺序)
    • [15.3 矩阵转置](#15.3 矩阵转置)
  • [16. 总结](#16. 总结)
• 二、代码示例

一、 API 全面介绍

1. 引言

Vec<T> 是 Rust 标准库中最常用、最核心的动态数组类型。它可以在运行时动态地增加或减少元素，并在堆上连续分配内存，因此访问效率极高。无论是日常业务开发、算法实现，还是系统编程，Vec<T> 几乎无处不在。

本文将从构造、访问、修改、容量管理、迭代、排序、转换、内存与安全 等多个维度，系统性地介绍 std::vec::Vec<T> 的所有常用 API，并附上可运行的代码示例，帮助你全面掌握这一核心数据结构。

2. 构造 Vec

2.1 空 Vec

let v: Vec<i32> = Vec::new();

2.2 带初始容量的空 Vec

let v: Vec<i32> = Vec::with_capacity(10);

2.3 宏 vec!

let v = vec![1, 2, 3];
let v2 = vec![0; 5]; // [0, 0, 0, 0, 0]

2.4 从迭代器构建

let v: Vec<i32> = (0..5).collect();
let v2: Vec<i32> = [1, 2, 3].iter().map(|x| x * 2).collect();

2.5 从数组/切片转换

let arr = [1, 2, 3];
let v = arr.to_vec();
let v2 = Vec::from(arr);
let v3: Vec<i32> = arr.into_iter().collect();

2.6 从其他类型转换

let s = String::from("hello");
let v: Vec<u8> = s.into_bytes(); // String -> Vec<u8>

3. 访问元素

3.1 索引访问

let v = vec![10, 20, 30];
let first = v[0]; // 10
// let x = v[5]; // 越界会 panic

3.2 get / get_mut（安全访问）

let v = vec![10, 20, 30];
assert_eq!(v.get(1), Some(&20));
assert_eq!(v.get(5), None);

let mut v = vec![10, 20, 30];
if let Some(x) = v.get_mut(1) {
    *x = 99;
}

3.3 first / last 及其可变版本

let v = vec![10, 20, 30];
assert_eq!(v.first(), Some(&10));
assert_eq!(v.last(), Some(&30));

let mut v = vec![10, 20, 30];
if let Some(x) = v.first_mut() {
    *x = 1;
}
if let Some(x) = v.last_mut() {
    *x = 3;
}

3.4 first_chunk / last_chunk（一次取多个）

let v = vec![1, 2, 3, 4, 5];
assert_eq!(v.first_chunk::<2>(), Some(&[1, 2]));
assert_eq!(v.last_chunk::<2>(), Some(&[4, 5]));

4. 添加元素

4.1 push（尾部追加）

let mut v = vec![1, 2];
v.push(3);
assert_eq!(v, [1, 2, 3]);

4.2 insert（指定位置插入）

let mut v = vec![1, 3];
v.insert(1, 2);
assert_eq!(v, [1, 2, 3]);

4.3 extend / extend_from_slice（批量追加）

let mut v = vec![1, 2];
v.extend([3, 4]);
v.extend_from_slice(&[5, 6]);
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

4.4 append（拼接并清空源 Vec）

let mut v1 = vec![1, 2];
let mut v2 = vec![3, 4];
v1.append(&mut v2);
assert_eq!(v1, [1, 2, 3, 4]);
assert!(v2.is_empty());

4.5 resize / resize_with（调整长度）

let mut v = vec![1, 2, 3];
v.resize(5, 0);
assert_eq!(v, [1, 2, 3, 0, 0]);

let mut v = vec![1, 2, 3];
v.resize_with(5, || 7);
assert_eq!(v, [1, 2, 3, 7, 7]);

5. 删除元素

5.1 pop（弹出尾部）

let mut v = vec![1, 2, 3];
assert_eq!(v.pop(), Some(3));
assert_eq!(v.pop(), Some(2));
assert_eq!(v.pop(), Some(1));
assert_eq!(v.pop(), None);

5.2 remove（按索引删除并返回）

let mut v = vec![1, 2, 3, 4];
let x = v.remove(1);
assert_eq!(x, 2);
assert_eq!(v, [1, 3, 4]);

5.3 swap_remove（交换后删除，O(1)）

let mut v = vec![1, 2, 3, 4];
let x = v.swap_remove(0);
assert_eq!(x, 1);
assert_eq!(v, [4, 2, 3]); // 最后一个元素移到索引 0

5.4 truncate（截断到指定长度）

let mut v = vec![1, 2, 3, 4, 5];
v.truncate(3);
assert_eq!(v, [1, 2, 3]);

5.5 clear（清空所有元素）

let mut v = vec![1, 2, 3];
v.clear();
assert!(v.is_empty());

5.6 retain / retain_mut（按条件保留）

let mut v = vec![1, 2, 3, 4, 5];
v.retain(|&x| x % 2 == 0);
assert_eq!(v, [2, 4]);

let mut v = vec![1, 2, 3, 4];
v.retain_mut(|x| {
    *x += 1;
    *x % 2 == 0
});
assert_eq!(v, [2, 4]);

5.7 dedup / dedup_by / dedup_by_key（去重）

let mut v = vec![1, 1, 2, 2, 3];
v.dedup();
assert_eq!(v, [1, 2, 3]);

let mut v = vec!["a", "A", "b", "B"];
v.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
assert_eq!(v, ["a", "b"]);

let mut v = vec![10, 20, 11, 21];
v.dedup_by_key(|x| *x / 10);
assert_eq!(v, [10, 11]);

5.8 drain（范围删除并返回迭代器）

let mut v = vec![1, 2, 3, 4, 5];
let removed: Vec<i32> = v.drain(1..3).collect();
assert_eq!(removed, [2, 3]);
assert_eq!(v, [1, 4, 5]);

5.9 split_off（从指定位置切分）

let mut v = vec![1, 2, 3, 4, 5];
let v2 = v.split_off(3);
assert_eq!(v, [1, 2, 3]);
assert_eq!(v2, [4, 5]);

6. 容量与内存管理

6.1 len / is_empty

let v = vec![1, 2, 3];
assert_eq!(v.len(), 3);
assert!(!v.is_empty());

6.2 capacity（当前容量）

let v: Vec<i32> = Vec::with_capacity(10);
assert!(v.capacity() >= 10);

6.3 reserve / reserve_exact（预留容量）

let mut v = vec![1, 2, 3];
v.reserve(100); // 至少预留 100 个元素空间
v.reserve_exact(100); // 尽量精确预留

6.4 shrink_to_fit / shrink_to（收缩容量）

let mut v: Vec<i32> = Vec::with_capacity(100);
v.push(1);
v.shrink_to_fit();
assert_eq!(v.capacity(), 1);

let mut v: Vec<i32> = Vec::with_capacity(100);
v.shrink_to(10);
assert!(v.capacity() <= 10);

6.5 into_boxed_slice（转为 Box<T>）

let v = vec![1, 2, 3];
let boxed: Box<[i32]> = v.into_boxed_slice();
assert_eq!(&*boxed, &[1, 2, 3]);

6.6 leak（泄漏内存，返回 &'static mut T）

let v = vec![1, 2, 3];
let static_slice: &'static mut [i32] = v.leak();

7. 切片与视图

7.1 as_slice / as_mut_slice

let v = vec![1, 2, 3];
let s: &[i32] = v.as_slice();

let mut v = vec![1, 2, 3];
let s: &mut [i32] = v.as_mut_slice();

7.2 切片操作

let v = vec![1, 2, 3, 4, 5];
let slice = &v[1..3]; // [2, 3]
let slice_mut = &mut v[..]; // 全部

8. 迭代与遍历

8.1 不可变迭代

let v = vec![1, 2, 3];
for x in &v {
    println!("{}", x);
}

8.2 可变迭代

let mut v = vec![1, 2, 3];
for x in &mut v {
    *x *= 2;
}

8.3 消费迭代（into_iter）

let v = vec![1, 2, 3];
for x in v {
    println!("{}", x);
}

8.4 带索引迭代

let v = vec!["a", "b", "c"];
for (i, x) in v.iter().enumerate() {
    println!("v[{}] = {}", i, x);
}

8.5 iter / iter_mut

let v = vec![1, 2, 3];
let mut it = v.iter();
assert_eq!(it.next(), Some(&1));

let mut v = vec![1, 2, 3];
let mut it = v.iter_mut();
if let Some(x) = it.next() {
    *x = 10;
}

8.6 windows / chunks / split

let v = vec![1, 2, 3, 4, 5];

// windows：滑动窗口
for w in v.windows(2) {
    println!("{:?}", w); // [1,2] [2,3] [3,4] [4,5]
}

// chunks：固定大小分块
for c in v.chunks(2) {
    println!("{:?}", c); // [1,2] [3,4] [5]
}

// split：按条件分割
for s in v.split(|x| *x == 3) {
    println!("{:?}", s); // [1,2] [4,5]
}

9. 查找与判断

9.1 contains

let v = vec![1, 2, 3];
assert!(v.contains(&2));

9.2 starts_with / ends_with

let v = vec![1, 2, 3, 4];
assert!(v.starts_with(&[1, 2]));
assert!(v.ends_with(&[3, 4]));

9.3 binary_search 系列（要求有序）

let v = vec![1, 3, 5, 7, 9];
assert_eq!(v.binary_search(&5), Ok(2));
assert_eq!(v.binary_search(&4), Err(2));

let v = vec![1, 3, 5, 7, 9];
assert_eq!(v.binary_search_by(|x| x.cmp(&5)), Ok(2));

let v = vec![(1, "a"), (3, "b"), (5, "c")];
assert_eq!(v.binary_search_by_key(&3, |&(k, _)| k), Ok(1));

9.4 partition_point（有序数组的分界点）

let v = vec![1, 2, 3, 4, 5, 6];
let idx = v.partition_point(|&x| x < 4);
assert_eq!(idx, 3);

10. 排序与反转

10.1 sort / sort_unstable

let mut v = vec![3, 1, 2];
v.sort();
assert_eq!(v, [1, 2, 3]);

let mut v = vec![3, 1, 2];
v.sort_unstable(); // 更快，但不保证相等元素顺序
assert_eq!(v, [1, 2, 3]);

10.2 sort_by / sort_by_key

let mut v = vec![3, 1, 2];
v.sort_by(|a, b| b.cmp(a)); // 降序
assert_eq!(v, [3, 2, 1]);

let mut v = vec!["bb", "a", "ccc"];
v.sort_by_key(|s| s.len());
assert_eq!(v, ["a", "bb", "ccc"]);

10.3 reverse

let mut v = vec![1, 2, 3];
v.reverse();
assert_eq!(v, [3, 2, 1]);

10.4 rotate_left / rotate_right

let mut v = vec![1, 2, 3, 4];
v.rotate_left(1);
assert_eq!(v, [2, 3, 4, 1]);

let mut v = vec![1, 2, 3, 4];
v.rotate_right(1);
assert_eq!(v, [4, 1, 2, 3]);

11. 聚合与统计

11.1 求和 / 求积

let v = vec![1, 2, 3, 4];
let sum: i32 = v.iter().sum();
let product: i32 = v.iter().product();
assert_eq!(sum, 10);
assert_eq!(product, 24);

11.2 最大值 / 最小值

let v = vec![3, 1, 4, 1, 5];
assert_eq!(v.iter().max(), Some(&5));
assert_eq!(v.iter().min(), Some(&1));

11.3 平均值

let v = vec![1.0, 2.0, 3.0, 4.0];
let avg = v.iter().sum::<f64>() / v.len() as f64;
assert_eq!(avg, 2.5);

12. 转换与扁平化

12.1 into_iter + collect（类型转换）

let v = vec![1, 2, 3];
let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();

12.2 concat / join（拼接）

let v = vec![vec![1, 2], vec![3, 4]];
let flat: Vec<i32> = v.concat();
assert_eq!(flat, [1, 2, 3, 4]);

let v = vec!["a", "b", "c"];
let joined = v.join("-");
assert_eq!(joined, "a-b-c");

12.3 flatten（扁平化嵌套迭代器）

let v = vec![vec![1, 2], vec![3, 4]];
let flat: Vec<i32> = v.into_iter().flatten().collect();
assert_eq!(flat, [1, 2, 3, 4]);

12.4 转 String

let v = vec!['h', 'e', 'l', 'l', 'o'];
let s: String = v.iter().collect();
assert_eq!(s, "hello");

13. 比较与相等

13.1 相等比较

let v1 = vec![1, 2, 3];
let v2 = vec![1, 2, 3];
assert_eq!(v1, v2);

13.2 与切片比较

let v = vec![1, 2, 3];
assert_eq!(v, [1, 2, 3][..]);

14. 内存与安全

14.1 内存布局

Vec<T> 由三部分组成：指向堆内存的指针、当前长度（len）、当前容量（capacity）。当 len == capacity 时再次 push 会触发重新分配。

let mut v = Vec::with_capacity(4);
println!("len={}, cap={}", v.len(), v.capacity()); // len=0, cap=4
v.push(1);
println!("len={}, cap={}", v.len(), v.capacity()); // len=1, cap=4

14.2 借用规则

let mut v = vec![1, 2, 3];
let first = &v[0]; // 不可变借用
// v.push(4); // 编译错误：不能同时可变借用
println!("{}", first);

14.3 越界安全

let v = vec![1, 2, 3];
// 推荐使用 get 避免 panic
if let Some(x) = v.get(10) {
    println!("{}", x);
} else {
    println!("索引越界");
}

15. 综合示例

15.1 统计词频

use std::collections::HashMap;

fn word_count(words: Vec<&str>) -> HashMap<&str, usize> {
    let mut map = HashMap::new();
    for w in words {
        *map.entry(w).or_insert(0) += 1;
    }
    map
}

fn main() {
    let words = vec!["apple", "banana", "apple", "cherry", "banana", "apple"];
    let counts = word_count(words);
    println!("{:?}", counts);
}

15.2 去重并保持顺序

fn dedup_keep_order(v: Vec<i32>) -> Vec<i32> {
    let mut seen = std::collections::HashSet::new();
    v.into_iter().filter(|x| seen.insert(*x)).collect()
}

fn main() {
    let v = vec![1, 2, 1, 3, 2, 4];
    assert_eq!(dedup_keep_order(v), [1, 2, 3, 4]);
}

15.3 矩阵转置

fn transpose(matrix: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    let rows = matrix.len();
    let cols = matrix[0].len();
    (0..cols)
        .map(|c| (0..rows).map(|r| matrix[r][c]).collect())
        .collect()
}

fn main() {
    let m = vec![vec![1, 2, 3], vec![4, 5, 6]];
    let t = transpose(m);
    assert_eq!(t, vec![vec![1, 4], vec![2, 5], vec![3, 6]]);
}

16. 总结

Vec<T> 是 Rust 中最灵活、最常用的动态数组类型。本文系统梳理了它的核心 API：

• 构造 ：Vec::new、vec!、collect、from
• 访问 ：索引、get、first、last
• 添加 ：push、insert、extend、append
• 删除 ：pop、remove、swap_remove、drain、retain
• 容量 ：reserve、shrink_to_fit、capacity
• 迭代 ：iter、iter_mut、into_iter
• 查找 ：contains、binary_search
• 排序 ：sort、sort_by、reverse
• 转换 ：concat、join、flatten

掌握这些 API，你就能在 Rust 中高效地处理动态数组。建议结合官方文档 std::vec::Vec 深入学习，并在实际项目中多加练习。

二、代码示例

fn main() {
    // ====================== 1. 创建 Vec ======================
    // 方式1：新建空vec
    let mut v1: Vec<i32> = Vec::new();
    // 方式2：宏 vec![]
    let mut v2 = vec![10, 20, 30, 40];
    // 方式3：指定初始容量（预分配，减少扩容）
    let mut v3:Vec<u32> = Vec::with_capacity(10);
    println!("v2={:?}, capacity(v3)={}", v2, v3.capacity());

    // ====================== 2. 添加元素 ======================
    let mut v = vec![1, 2];

    v.push(3); // 尾部追加
    println!("push 3 → {:?}", v);

    v.insert(1, 99); // 在索引1位置插入99，后面元素后移，性能较差
    println!("insert(1,99) → {:?}", v);

    v.extend([100, 200]); // 追加迭代器全部元素
    println!("extend → {:?}", v);

    v.extend_from_slice(&[500, 600]); // 追加切片
    println!("extend_from_slice → {:?}", v);

    // ====================== 3. 读取元素 ======================
    let v = vec![10, 20, 30, 40];

    // 下标访问，越界panic
    println!("v[1]={}", v[1]);

    // 安全访问，返回Option，不panic
    match v.get(2) {
        Some(val) => println!("get(2) → {}", val),
        None => println!("下标不存在"),
    }
    println!("get(10) → {:?}", v.get(10));

    // 首尾
    println!("first={:?}, last={:?}", v.first(), v.last());

    // ====================== 4. 删除元素 ======================
    let mut v = vec![1, 2, 3, 4, 5];

    let pop_val = v.pop(); // 删除并返回尾部元素 Option<T>
    println!("pop {:?}, vec:{:?}", pop_val, v);

    let rm = v.remove(1); // 删除指定索引，返回被删元素；后面元素移位
    println!("remove(1)={}, vec:{:?}", rm, v);

    v.truncate(2); // 截断，只保留前2个元素
    println!("truncate(2) → {:?}", v);

    let mut v = vec![1, 2, 3, 4, 5];
    v.retain(|x| *x % 2 == 0); // ✅保留满足条件的元素，其余删除（你之前代码用到！）
    println!("retain 偶数 → {:?}", v);

    v.clear(); // 清空所有元素，容量不变
    println!("clear后 len={}, cap={}", v.len(), v.capacity());

    // ====================== 5. 长度、容量、内存 ======================
    let mut v = Vec::with_capacity(8);
    v.push(1);
    v.push(2);
    println!("len={}, capacity={}", v.len(), v.capacity());
    println!("is_empty={}", v.is_empty()); // 是否为空

    v.reserve(10); // 预留至少10个额外空间，可能扩容
    println!("reserve后 cap={}", v.capacity());

    v.shrink_to_fit(); // 尽量释放多余内存，让capacity≈len
    println!("shrink_to_fit cap={}", v.capacity());

    // ====================== 6. 迭代遍历 ======================
    let v = vec![10, 20, 30];

    // 不可变迭代，拿引用
    for item in v.iter() {
        print!("{} ", item);
    }
    println!();

    // 可变迭代，可以修改元素
    let mut v = vec![1, 2, 3];
    for item in v.iter_mut() {
        *item *= 2;
    }
    println!("iter_mut 修改后 {:?}", v);

    // 获取所有权迭代，vec被消耗掉，不能再用
    for item in v.into_iter() {
        print!("{} ", item);
    }
    // println!("{:?}",v); // ❌ v已经失效

    // ====================== 7. 切片 & 转换 ======================
    let v = vec![1, 2, 3, 4, 5];
    let s = &v[1..3]; // 切片 &[T]，不拥有所有权
    println!("切片 &v[1..3] = {:?}", s);

    // vec转数组（只有长度固定才行，返回Option）
    let arr_res: Result<[i32; 5], _> = v.try_into();
    println!("vec转数组 {:?}", arr_res);

    // 数组转vec
    let arr = [100, 200];
    let v_from_arr: Vec<i32> = arr.into();
    println!("数组转vec {:?}", v_from_arr);

    // ====================== 8. 排序、查找、过滤 ======================
    let mut v = vec![3, 1, 4, 2];
    v.sort(); // 升序排序
    println!("sort {:?}", v);

    v.sort_by(|a, b| b.cmp(a)); // 降序
    println!("sort_by 降序 {:?}", v);

    v.reverse(); // 反转
    println!("reverse {:?}", v);

    let v = vec![10, 20, 30, 40];
    println!("contains(&20)={}", v.contains(&20)); // 是否包含元素

    // find返回Option引用
    let found = v.iter().find(|&&x| x > 25);
    println!("find >25 → {:?}", found);

    // filter迭代器收集新vec
    let filtered: Vec<_> = v.iter().filter(|&&x| x > 20).collect();
    println!("filter collect → {:?}", filtered);

    // map映射生成新vec
    let mapped: Vec<_> = v.iter().map(|x| x * 10).collect();
    println!("map collect → {:?}", mapped);

    // ====================== 9. split、dedup去重 ======================
    let mut v = vec![1,1,2,2,3,3];
    v.dedup(); // 去除**相邻重复**，不是全部去重！
    println!("dedup {:?}", v);

    // ====================== 10. append 两个vec转移所有权 ======================
    let mut a = vec![1,2];
    let mut b = vec![3,4];
    a.append(&mut b); // b的全部元素移动到a；b变成空vec
    println!("a={:?}, b={:?}", a, b);

    // ====================== 11. swap 删除（高性能删除，不保留顺序） ======================
    let mut v = vec![10,20,30,40];
    v.swap_remove(1); // 将最后一个元素和目标索引交换，再pop；速度快，顺序打乱
    println!("swap_remove(1) → {:?}", v);
}

warning: `modbus-debug-assistant` (bin "modbus-debug-assistant") generated 4 warnings (run `cargo fix --bin "modbus-debug-assistant" -p modbus-debug-assistant` to apply 4 suggestions)                                           
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 21.17s
     Running `target\debug\modbus-debug-assistant.exe`
v2=[10, 20, 30, 40], capacity(v3)=10
push 3 → [1, 2, 3]
insert(1,99) → [1, 99, 2, 3]
extend → [1, 99, 2, 3, 100, 200]
extend_from_slice → [1, 99, 2, 3, 100, 200, 500, 600]
v[1]=20
get(2) → 30
get(10) → None
first=Some(10), last=Some(40)
pop Some(5), vec:[1, 2, 3, 4]
remove(1)=2, vec:[1, 3, 4]
truncate(2) → [1, 3]
retain 偶数 → [2, 4]
clear后 len=0, cap=5
len=2, capacity=8
is_empty=false
reserve后 cap=16
shrink_to_fit cap=2
10 20 30 
iter_mut 修改后 [2, 4, 6]
2 4 6 切片 &v[1..3] = [2, 3]
vec转数组 Ok([1, 2, 3, 4, 5])
数组转vec [100, 200]
sort [1, 2, 3, 4]
sort_by 降序 [4, 3, 2, 1]
reverse [1, 2, 3, 4]
contains(&20)=true
find >25 → Some(30)
filter collect → [30, 40]
map collect → [100, 200, 300, 400]
dedup [1, 2, 3]
a=[1, 2, 3, 4], b=[]
swap_remove(1) → [10, 40, 30]
PS E:\leaning\slint\test>