数组切片 &[T]
什么是切片
切片(Slice)是对一段连续内存中元素序列的引用。它的类型写作 &[T],其中 T 是元素类型。切片本身不拥有数据,它只是"借用"了某个数组、Vec 或其他连续内存区域中的一部分(或全部)元素。
切片在内存中是一个"胖指针"(fat pointer),由两部分组成:一个指向数据起始位置的指针,加上一个表示元素个数的长度。所以 &[T] 占 16 字节(64 位系统上,指针 8 字节 + 长度 8 字节)。
fn main() {
let arr = [1, 2, 3, 4, 5];
// 从数组创建切片(引用整个数组)
let slice: &[i32] = &arr;
println!("切片:{:?}", slice); // [1, 2, 3, 4, 5]
println!("切片长度:{}", slice.len()); // 5
// 引用数组的一部分
let partial: &[i32] = &arr[1..4];
println!("部分切片:{:?}", partial); // [2, 3, 4]
// 切片的内存大小(胖指针)
println!("&[i32] 大小:{} 字节", std::mem::size_of::<&[i32]>()); // 16
println!("[i32; 5] 大小:{} 字节", std::mem::size_of::<[i32; 5]>()); // 20
}切片的来源
切片可以从多种数据源创建。
fn main() {
// 从数组创建切片
let array = [10, 20, 30, 40, 50];
let s1: &[i32] = &array; // 整个数组
let s2: &[i32] = &array[1..3]; // 部分
// 从 Vec 创建切片
let vec = vec![1, 2, 3, 4, 5];
let s3: &[i32] = &vec; // 整个 Vec
let s4: &[i32] = &vec[2..]; // 从索引 2 到末尾
// 字符串切片(&str 就是 &[u8] 的特化版本)
let text = "hello";
let bytes: &[u8] = text.as_bytes();
println!("{:?}, {:?}, {:?}, {:?}, {:?}", s1, s2, s3, s4, bytes);
}切片作为函数参数
切片最大的价值是让函数能接受任意长度的数据。不管你传的是 [i32; 3]、[i32; 100] 还是 Vec<i32>,都可以统一用 &[i32] 接收。
// 这个函数可以接受任意长度的 i32 序列
fn sum(data: &[i32]) -> i32 {
let mut total = 0;
for &val in data {
total += val;
}
total
}
// 查找最大值
fn find_max(data: &[i32]) -> Option<i32> {
if data.is_empty() {
return None;
}
let mut max = data[0];
for &val in &data[1..] {
if val > max {
max = val;
}
}
Some(max)
}
fn main() {
// 传数组
let arr = [1, 2, 3];
println!("数组的和:{}", sum(&arr));
// 传不同长度的数组
let arr2 = [10, 20, 30, 40, 50];
println!("数组的和:{}", sum(&arr2));
// 传 Vec
let vec = vec![100, 200, 300];
println!("Vec 的和:{}", sum(&vec));
// 传部分切片
println!("部分的和:{}", sum(&arr2[1..4])); // 20+30+40=90
// 查找最大值
println!("最大值:{:?}", find_max(&arr2)); // Some(50)
println!("空的最大值:{:?}", find_max(&[])); // None
}可变切片 &mut [T]
可变切片允许你通过切片修改原始数据。
fn main() {
let mut numbers = [5, 3, 8, 1, 9, 2, 7];
// 创建可变切片
let slice: &mut [i32] = &mut numbers;
// 通过切片修改原始数据
slice[0] = 100;
println!("修改后:{:?}", numbers); // [100, 3, 8, 1, 9, 2, 7]
// 切片自带 sort 方法
let slice = &mut numbers[..];
slice.sort();
println!("排序后:{:?}", numbers); // [1, 2, 3, 7, 8, 9, 100]
// 反转
numbers.reverse();
println!("反转后:{:?}", numbers); // [100, 9, 8, 7, 3, 2, 1]
}
// 函数接受可变切片参数
fn double_values(data: &mut [i32]) {
for val in data.iter_mut() {
*val *= 2;
}
}切片的常用方法
fn main() {
let data = [10, 20, 30, 40, 50, 60, 70];
let slice = &data[..];
// 长度和是否为空
println!("长度:{}", slice.len()); // 7
println!("为空:{}", slice.is_empty()); // false
// 获取第一个和最后一个
println!("第一个:{:?}", slice.first()); // Some(&10)
println!("最后一个:{:?}", slice.last()); // Some(&70)
// 安全地获取指定位置
println!("索引 3:{:?}", slice.get(3)); // Some(&40)
println!("索引 99:{:?}", slice.get(99)); // None
// 是否包含某个值
println!("包含 30:{}", slice.contains(&30)); // true
println!("包含 99:{}", slice.contains(&99)); // false
// 分割切片
let (left, right) = slice.split_at(3);
println!("左半:{:?}", left); // [10, 20, 30]
println!("右半:{:?}", right); // [40, 50, 60, 70]
// 窗口迭代
println!("长度为 3 的窗口:");
for window in slice.windows(3) {
println!(" {:?}", window);
}
// 分块迭代
println!("每 3 个一组:");
for chunk in slice.chunks(3) {
println!(" {:?}", chunk);
}
// 二分查找(数据必须已排序)
let sorted = [1, 3, 5, 7, 9, 11];
println!("查找 7:{:?}", sorted.binary_search(&7)); // Ok(3)
println!("查找 6:{:?}", sorted.binary_search(&6)); // Err(3)
}基本示例
统计一组数据中连续递增子序列的最大长度:
// 找出切片中最长的连续递增子序列长度
fn longest_increasing_run(data: &[i32]) -> usize {
if data.len() <= 1 {
return data.len();
}
let mut max_len = 1;
let mut current_len = 1;
// 使用 windows(2) 比较相邻元素
for pair in data.windows(2) {
if pair[1] > pair[0] {
current_len += 1;
if current_len > max_len {
max_len = current_len;
}
} else {
current_len = 1;
}
}
max_len
}
fn main() {
let data = [1, 3, 5, 2, 4, 6, 8, 1, 2];
// ----- -----------
// 长度3 长度4
println!("数据:{:?}", data);
println!("最长连续递增长度:{}", longest_increasing_run(&data)); // 4
// 传空切片也没问题
println!("空数据:{}", longest_increasing_run(&[])); // 0
// 传 Vec 也行
let vec_data = vec![5, 4, 3, 2, 1];
println!("递减数据:{}", longest_increasing_run(&vec_data)); // 1
}常见问题
问题一:&[T] 和 [T; N] 有什么区别?
| 对比项 | [T; N](数组) | &[T](切片) |
|---|---|---|
| 拥有数据 | 是 | 否(只是引用) |
| 大小 | N * size_of::<T>() | 固定 16 字节(胖指针) |
| 长度 | 编译期固定,是类型的一部分 | 运行时确定,不是类型的一部分 |
| 存储位置 | 栈 | 引用的数据可以在栈或堆 |
| 灵活性 | 只能接受精确匹配长度的数据 | 可以接受任意长度的数据 |
问题二:切片能独立存在吗?
切片类型 [T](不带 &)是一个"动态大小类型"(DST),不能直接作为变量的类型。你总是通过引用(&[T] 或 &mut [T])来使用它。
问题三:切片会复制数据吗?
不会。切片只是一个指针加长度,它借用原始数据而不复制。创建切片的成本是固定的(创建一个胖指针),和数据长度无关。
问题四:对切片排序会影响原始数据吗?
如果是可变切片(&mut [T]),排序会直接修改原始数据。如果是不可变切片(&[T]),不能调用 sort()。
适用场景
- 函数参数:接受任意长度的同类型序列
- 子序列操作:在不复制数据的情况下处理数组或 Vec 的一部分
- 零成本抽象:切片让你无需知道底层数据是数组还是 Vec
- 数据分析:用
windows()、chunks()等方法进行滑动窗口分析 - 二分查找:对有序切片进行高效查找
注意事项
- 切片只是借用,不拥有数据。原始数据必须在切片存活期间保持有效
&[T]是不可变切片,&mut [T]是可变切片- 切片的索引越界和数组一样会 panic,安全访问用
.get() - 创建切片时的范围(如
&arr[1..4])不能越界 - 切片可以从切片创建(子切片),不会有性能问题
- 把数组传给接受
&[T]的函数时,Rust 会自动做引用转换(deref coercion)
总结
切片 &[T] 是对连续内存中一段元素序列的引用,由指针和长度两部分组成。它不拥有数据,只是借用。切片的核心价值是解耦函数参数和具体的数据容器——一个接受 &[i32] 的函数可以处理数组、Vec 或其他切片的数据,不需要为每种容器写不同的函数。切片提供了丰富的方法(first、last、contains、windows、chunks、binary_search 等)来操作数据。可变切片 &mut [T] 还可以原地修改、排序和反转数据。