一、概要
数组（arry)
定义：数组是一组拥有相同类型T的对象的集合，在内存中是连续存储的。
数组的特征：
数组声明分配顺序内存块。长度固定。数组是静态的。这意味着数组一旦初始化就无法调整大小。每个内存块代表一个数组元素。数组元素由一个唯一的整数标识，称为元素的下标/索引。注意：数组下边从0开始。填充数组元素称为数组初始化。数组元素值可以更新或修改，但不能删除。数组是存储在栈上。因此访问速度更快。
声明和初始化
rust提供3种语法
1.最基本的语法，指定每一个元素的初始值
let variable_name:[dataType; size] = [ value1, value2, value3];
例如
let arr:[i32; 4] = [10, 20, 30, 40];
2.省略数组类型的语法
let variable_name = [value1, value2, value3];
例如
let arr = [ 10, 20, 30, 40];
3.指定默认初始值的语法，这种语法称为默认值初始化。
如果不想为每一个元素指定初始值，则可以为所有元素指定一个默认的初始值。
let variable_name:[dataType;size] = [default_value_for_elements; size];
例如 ：为每一个元素指定初始值为-1
let arr:[i32; 4] = [-1; 4];
访问数组元素
fn main(){
let arr = [9, 8, 7, 6, 5]
//let arr:[i32; 4] = [9, 8, 7, 6, 5];
let first = arr[0]; //获取arr数组的第一个元素
let second = arry[1]; //获取arr数组的第二个元素
}
数组长度 len()
fn main(){
let arr:[i32; 4] = [-1; 4];
println!("arry size is :{}", arr.len());
}
//输出结果
arry size is :4
循环遍历数组for in
fn main(){
let arr:[i32; 4] = [10, 20, 30, 40];
for i in 0..4 {
println!("i is : {}, value is : {}", i, arr[i]);
}
//输出结果
i is : 0, value is : 10
i is : 1, value is : 20
i is : 2, value is : 30
i is : 3, value is : 40
迭代数组 iter()
fn main(){
let arr:[i32; 4] = [10, 20, 30, 40];
for val in arr.iter(){
println!("value is : {}", val);
}
}
//输出结果
value is : 10
value is : 20
value is : 30
value is : 40
可变数组
fn main(){
let mut arr:[10, 20, 30, 40];
arr[1] = 0;
println!("{:?}", arr);
}
//输出结果
[10, 0, 30, 40]
数组切片
fn main（）{
let a: [i32; 5] = [1, 2, 3, 4, 5];
let slice: &[i32] = &a[1..3];
assert_eq!(slice, &[2, 3]);
}
数组作为函数参数
数组可以作为函数的参数，传递方式有传值传递和引用传递两种方式。
传值传递就是传递数组的一个副本给函数做参数，函数对副本的任何修改都不会影响到原来的数组。
fn main(){
let arr = [10, 20, 30]
update(arr);
println!("Inside main {:?});
}
fn update(mut arr:[i32; 3]){
for i in 0..3 {
arr[i] = 0;
}
println!("Inside update {:?}", arr);
}
//输出结果
Inside update [0, 0, 0]
Inside main [10, 20, 30]
引用传递就是传递数组在内存上的位置给函数左参数，因此函数对数组的任何修改都会影响到原来的数组。
fn main(){
let mut arr = [10, 20, 30];
update(&mut arr);
println!("Inside main {:?}", arr);
}
fn update(arr: &mut [i32; 3]){
for i in 0..3 {
arr[i] = 0;
}
println!("Inside update {:?}", arr);
}
//输出结果
Inside update [0, 0, 0]
Inside main [0, 0, 0]
属性、方法和函数
len(): 返回数组的长度。
let arr = [1, 2, 3, 4, 5];
assert_eq!(arr.len(), 5);
is_empty(): 判断数组是否为空，如果长度为0返回true，否则返回false。
let arr: [i32; 0] = [];
assert_eq!(arr.is_empty(), ture);
first():返回数组的第一个元素的引用，如果数组为空返回None。
let arr = [1, 2, 3];
assert_eq!(arr.first(), Some(&1));
first_mut(): 返回数组的第一个元素的可变引用，如果数组为空，则返回None。
let mut arr = [1, 2, 3];
if let Some(n) = arr.first_mut(){
*n *=2;
}
assert_eq!(arr, [2,2,3]);
last():返回数组的最后一个元素的引用，如果数组为空返回None。
let arr = [1, 2, 3];
assert_eq!(arr.last(), Some(&3));
last_mut():返回数组的最后一个元素的可变引用，如果数组为空，则返回None。
let mut arr = [1, 2, 3];
if let Some(n) = arr.last_mut(){
*n *=2;
}
assert_eq!(arr, [1, 2, 6]);
get():通过索引获取数组元素的引用，如果索引越界返回None。
let mut arr = [1, 2, 3];
assert_eq!(arr.get(1), Some(&2));
assert_eq!(arr.get(3), None);
get_mut(): 返回给定索引处的元素的可变引用，如果索引越界，则返回None。
let mut arr = [1, 2, 3];
if let Some(n) = arr.get_mut(1){
*n *=2;
}
assert_eq!(arr, [1, 4, 3]);
contains(): 判断数组是否包含指定的元素。
let arr = [1, 2, 3];
assert_eq!(arr.contcains(&3));
assert|_eq!(arr.contcains(&6));
starts_with(): 判断数组是否以指定的前缀开头。
let arr = [1, 2, 3, 4, 5];
assert_eq!(arr.starts_with(&[1, 2, 3]));
assert_eq!(arr.starts_with(&[2,3, 4]));
let arr = [1, 2, 3, 4, 5];
assert_eq!(arr.ends_with(&[4, 5]));
assert_eq!(arr.ends_with(&[3, 4, 5]));
repeat():创建重复指定次数的数组。
let arr = [1, 2];
let repeated: Vec
assert_eq!(repeat, [1, 2, 1, 2, 1, 2]);
fill():将数组中所有元素替换为给定的值。
let mut arr = [1, 2, 3];
arr.fill(0);
assert_eq!(arr, [3, 2, 1});
swap(): 交换数组中两个元素的位置。
let mut arr = [1, 2, 3];
arr.swap(0, 2);
assert_eq!(arr, [3, 2, 1]);
binary_search_by_key(): 在有序数组中搜索指定键的元素，在找到元素时返回其索引，否则返回应该插入元素的位置的索引，维持数组的有序状态。
let arr = [(1, "one"), (3, "three"), (5, "five"), (7, "seven"), (9, "nine")];
let result = arr.binary_search_by_key(&7, |&key, _) key);
assert_eq!(result, Ok(3));
let arr = [(1, "apple"), (3, "banana"), （5， "cherry"), (7, "pear"), (9, "watermelon")];
assert_eq!(arr.binary_search_by_key(&5, |&(k, _)| k), Ok(2));
assert_eq!(arr.binary_search_by_key(&4, |&(k, _)| k), Err(2));
assert_eq!(arr.binary_search_by_key(&10, |&(k, _)| k), Err(5));
iter():返回数组的迭代器，可用于遍历数组中的元素。
let arr = [1, 2, 3];
for i in arr.iter(){
println!("{}", i);
}
//输出结果
1 2 3
iter_mut():返回一个可变的迭代器，可用于遍历和修改数组中的元素。
let mut arr = [1, 2, 3];
let s =arr.as_mut();
s[1] = 4;
assert_eq!(arr, [1, 4, 3]);
into_iter():返回一个消耗性迭代器，可对数组进行所有权转移，在迭代过程中释放数组的所有权。
let arr = [1, 2, 3];
let v:Vec
assert_eq!(v, vec![2, 4, 6];
as_mut(): 返回一个可变引用的切片，可以修改数组中的元素。
let mut arr = [1, 2, 3];
let s = arr.as_mut();
s[1] = 4;
assert_eq!(1, 4, 3]);
as_ptr():返回数组的指针。
let arr = [ 1, 2, 3];
let p = arr.ptr();
unsafe{
println!("{}", *p.offset(1));
}
//输出结果
2
split():根据条件分割数组，返回一个可迭代的切片集合。
let arr = [1, 2, 3, 4, 5];
let mut splits = arr.split(|x| x%2 == 0);
let s1 = splits.next().unwrap();
let s2 = splits.next().unwrap();
let s3 = splits.next().unwrap();
assert_eq!(s1, [1]);
assert_eq!(s2, [3]);
assert_eq!(s3, [5]);
split_at():从数组中分割出两个切片，将数组分成两部分。
let arr = [1, 2, 3, 4, 5];
let (left, right) = arr.split_at(2);
assert_eq!(left, [1, 2]);
assert_eq!(right, [3, 4, 5]);
split_first():返回数组中的第一个元素。
let arr = [1, 2, 3, 4, 5];
let (first, rest) = arr.split_first().unwrap();
assert_eq!(*first, 1);
assert_eq!(rest, &[2, 3, 4, 5]);
split_first_mut():返回一个数组的第一个可变引用。
let mut arr = [1, 2, 3, 4, 5];
let (first, rest) = arr.split_mut().unwrap();
*first = 0;
assert_eq!(arr, [0, 2, 3, 4, 5]);
chunks():返回以恶可迭代的切片集合，每个切片包含指定大小的元素。
let arr = [1, 2, 3, 4, 5];
let mut chunks = arr.chunks(2);
let c1 = chunks.next().unwrap();
let c2 = chunks.next().unwrap();
let c3 = chunks.next().unwrap();
assert_eq!(c1, [1, 2]);
assert_eq!(c2, [3, 4]);
assert_eq!(c3, [5]);
chunks_mut():返回一个可变的可迭代切片集合，每个切片包含指定大小的元素。
let arr = [1, 2, 3, 4, 5];
for chunk in arr.chunks_mut(2){
chunk[0] +=1;
}
assert_eq!(arr, [2, 2, 4, 4, 5]);
chunks_exact():返回可迭代的切片集合，每个切片包含指定大小的元素，最后不足一个切片的部分将被忽略。
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
let mut chunks = arr.chunks_exact(3);
let c1 = chunks.next().unwrap();
let c2 = chunks.next().unwrap();
let c3 = chunks.next().unwrap();
let c4 = chunks.next().unwrap();
assert_eq!(c1, [1, 2, 3]);
assert_eq!(c2, [4, 5, 6]);
assert_eq!(c3, [7, 8, 9]);
assert_eq!(c4, [10, 11]);
chunks_exact_mut(): 返回可变的可迭代的切片集合，每个切片包含指定大小的元素，最后不足一个切片的部分将被忽略。
let mut arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
for chunk in arr.chunks_exact_mut(3){
chunk[0] += 1;
}
assert_eq!(arr, [2, 2, 4, 5, 6, 8, 7, 8, 9]);
join():将数组中的元素按指定的分隔符连接成一个字符串。
let arr = [1, 2, 3];
let joined = arr.join(", ");
assert_eq!(joined, "1, 2, 3");
let arr = ["one", "two", "three"];
let s = arr.join(", ");
assert_eq!(arr, "one, two, three");
reverse():反转数组中元素的顺序。
let mut arr = [1, 2, 3, 4, 5];
arr.reverse();
assert_eq!(s, [5, 4, 3, 2, 1]);
sort():对数组进行排序，按元素大小升序排序。
let arr = [3, 1, 4, 2, 5];
arr.sort();
assert_eq!(arr, [1, 2, 3, 4, 5]);
sort_by():对数组进行排序，按指定的比较函数进行排序。
let mut arr = ["apple", "banana", "cherry", "pear", "watermelon"];
arr.sort_by(|a, b| a.len().cmp(&b.len()));
assert_eq!(arr, ["pear", "apple", "banana", "cherry", "watermelon"]);
sort_by_key():对数组进行排序，按指定的键进行排序。
let mut arr = [(3, "banana"), (1, "apple"), (5, "cherry"), (7, "pear"), (9, "watermelon")];
arr.sort_by_key(|&k, _)| k);
assert_eq!(arr, [(1,"apple", (3, "banana"), (5, "cherry"), (7, "pear"), (9, "watermelon")];
map():将数组中的每个元素应用给定的函数，并返回一个新的数组。
let arr = [1, 2, 3];
let arr2 = arr.map(|n| n*2);
assert_eq!(arr2, [2, 4, 6]);
rotate_left():循环移动数组元素，将第一个元素移动到数组末尾。
let mut arr = [1, 2, 3, 4, 5];
arr.rotate_left(2);
assert_eq!(arr, [3, 4, 5, 1, 2]);
rotate_right():循环移动数组元素，将最后一个元素移动到数组开头。
let mut arr = [1, 2, 3, 4, 5];
arr.rotate_right(2);
assert_eq!(arr, [ 4, 5, 1, 2, 3]);
to_string():将数组转换为字符串类型。
let arr = [1, 2, 3];
let s = arr.to_string();
assert_eq!(s, "[1, 2, 3]");
to_vec():将数组转换为向量类型(Vec)。
let arr = [1, 2, 3];
let vec = arr.to_vec();
assert_eq!(s, vec![1, 2, 3]);
to_slice():将数组转换为切片类型，并且可以指定开始和结束位置。
let arr = [1, 2, 3, 4, 5];
let slice = arr.to_slice();
assert_eq!(slice, &[1, 2, 3, 4, 5]);
into_iter():返回一个将数组转换为迭代器的方法。
let arr = [1, 2, 3];
for n in arr.into_iter(){
println!("{}", n);
}
try_fold():对数组中的每个元素应用给定的函数，并且在每次应用后返回一个Result类型，最后将所有Ok类型的值聚合在一起。
let arr = ["1", "2", "three", "4", "five"];
let result = arr.try_fold(0, |acc, n|{
if let Ok(num) = n.parse::
Ok(acc + num)
} else{
Err(())
}
});
assert_eq!(result, Err(()));
try_for_each():对数组中的每个元素应用给定的函数，并且在 每次应用后返回一个Result类型，如果所有应用都成功，则返回Ok(())。
let arr = ["1", "2", "3"];
let result = arr.try_for_each(|n| {
if n.parse::
Ok(())
} else {
Err(())
}
});
assert_eq!(result, Ok(()));
permutations():返回一个可迭代的集合，包含数组中所有元素的所有可能的排列组合。
let arr = [1, 2, 3];
let mut permutations = arr.permutations();
assert_eq!(permutations.next(), Some([1, 2, 3]));
assert_eq!(permutations.next(), Some([1, 3, 2]));
assert_eq!(permutations.next(), Some([2, 1, 3]));
assert_eq!(permutations.next(), Some([2, 3, 1]));
assert_eq!(permutations.next(), Some([3, 1, 2]));
assert_eq!(permutations.next(), Some([3, 2, 1]));
zip():将两个数组压缩成一个元组的集合。
let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let result:Vec<_> = arr1.iter().zip(arr2.iter()).collect();
assert_eq!(result, [(1, 4), (2, 5), (3, 6)]);
相关链接
您阅读本篇文章共花了：
发表评论