Rust 集合类型之Vector 向量

定义

在rust语言中，Vector（向量）是一种动态数组，可以存储相同类型的元素。Vector根据需要自动调整大小，而不需要手动管理内存。

Vector是标准库的一种集合类型，通过使用Vec<T>来声明。

创建vector

创建一个新的空vector，可以调用 Vec::new函数。

let v: vec<i32> = Vec::new();//新建一个空的vector来存储i32的值

为了方便rust提供了vec!宏，这个宏根据我们提供的值来创建一个新的vector。下面新建一个拥有值1、2和3的vec<i32>。推断为i32是因为这是默认整型类型。

let v = vec![1, 2, 3];//新建一个包含初始值的vector

更新vector

向新建的vector增加元素，可以使用push方法。

//使用push方法向vector增加值

let mut v = Vec::new();

    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);

读取vector的元素

有两种方法引用vector中的存储的值：

• 通过索引
• 使用get方法

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

let third: &i32 = &v[2]; //通过索引值2来获取第三个元素
println!("The third element is {third}");

let third: Option<&i32> = v.get(2); //调用get方法得到一个math的Option<&T>
match third {
    Some(third) => println!("The third element is {third}",
    None => println!("There is no third element."),
}

遍历vector的元素

//通过for循环遍历vector的元素并打印

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

我们也可以遍历可变vector的每一个元素的可变引用以便能改变它们。

let mut v = vec![1, 2, 3, 4, 5];
for i in &mut v {
    *i += 100;
}

为了修改可变引用所指向的值，在使用 += 运算符之前必须使用解引用运算符（*）获取 i 的值。

使用枚举来储存多种类型

vector只能储存相同类型的值。但是有时我们需要储存一系列不同类型的值的时候，使用枚举以便在vector中存放不同类型的数据。

enum SpreadsheetCell {
    Int(i32),
    Float(f64),
    Text(String),
}

let row = vec![
    SpreadsheetCell::Int(3),
    SpreadsheetCell::Text(String::from("blue")),
    SpreadsheetCell::Float(10.12),
];

Vector的常用方法

//new方法:创建一个空的Vec

let mut vec: Vec<i32> = Vec::new();
println!("声明一个空的Vec {:?}, 长度 {}", vec, vec.len());

//输出结果：
//声明一个空的Vec [] , 长度 0

//repeat方法：重复

let mut vec = [1].repeat(5);
println!("声明一个重复元素的Vec： {:?}", vec);

//输出结果
//声明一个重复元素的Vec： [1, 1, 1, 1, 1]

//with_capacity（）方法：创建一个带有指定容量的Vec

let mut vec = Vec::with_capacity(10);
println!("声明一个初始长度为10的Vec： {:?}, 长度 len{}, capacity {}", 
    vec,
    vec.len(),
    vec.capacity()
    );

//输出结果
//声明一个初始长度为10的Vec： {:?}, 长度 0, capacity 10

// is_empty() 方法：检查Vec是否为空

let mut vec = vec![1, 5, 10, 2, 15];
let n: Option<&i32> = vec.get(0);
println!("Vec是否为空： {}， 元素0： {}", vec.is_empty(), n.is_none());

//输出结果:
// Vec是否为空： flash， 元素0： false

// push() 方法：将一个元素添加到Vec的末尾

let mut vec = Vec![1, 5];
vec.push(13); //追加到末尾
println!("追加一个元素到末尾： {:?}", vec);

vec.extend(1, 2, 3].iter().copied()); //追加到末尾
println!("追加一组元素到末尾： {:?}", vec);

let mut vec1 = [1].repeat(2);
vec.append(&mut vec1);
println!("追加一组元素到末尾： {:?}", vec);

//输出结果：
//追加一个元素到末尾： [1, 5, 13]
  追加一个元素到末尾： [1, 5, 13, 1, 2, 3]
  追加一个元素到末尾： [1, 5, 13, 1, 2, 3, 1, 1]

//remove() 方法： 移除Vec中指定位置的元素
//pop() 方法：移除并返回Vec的最后一个元素

let mut vec = vec![1, 5, 6];
vec.remove(vec.len() -1);
println!("删除末尾的元素： {:?}, 长度 {}”， vec, vec.len());

vec.pop();
println!("删除末尾的元素： {:?}, 长度 {}”， vec, vec.len());

//输出结果：
//删除末尾的元素： [1, 5], 长度 2
  删除末尾的元素： [1], 长度 1

//修改

let mut vec = vec![1, 5, 6];
vec[0] = 2;
println!("第一个元素被修改 {:?}", vec);

//输出结果：
  第一个元素被修改 [2, 5, 6]

// sort() 方法：排序

let mut vec = vec![1, 9, 6];
println!("排序前： {:?}", vec);
vec.sort();
println!("排序后： {:?}", vec);

//输出结果：
  排序前： [1, 9, 6]
  排序后： [1, 6, 9]

// contains()方法： 搜索

let cs = vec.contains(&1);
println!(是否有元素 {:?}: {}", vec, cs);

//输出结果：
  是否有元素 [1, 9 ,6]: true

// 条件筛选

let mut vec = vec![1, 2, 4, 5];
vec.retain(|&x| x % 2 == 0);
println!("条件筛选，只留下能整除2的 {:?}, 长度 {}", vec, vec.len());

//输出结果：
  条件筛选，只留下能整除2的 [2, 4], 长度 2

// resize() 方法

let mut vec = vec![1, 2, 3, 4];
vec.resize(2, 0);
println!("new_len小于len,截断 {:?}", vec);

vec.resize(4, 0);
println!("new_len大于len，按插值进行扩展 {:?}", vec);

//输出结果：
  new_len小于len,截断 [1, 2]
  new_len大于len，按插值进行扩展 [1, 2, 0, 0]

// split_off() 方法

let mut vec = vec![1, 1, 1, 2, 3];
let vec1 = vec.split_off(2);
println!("按元素下标切分为2 vec: {:?}, vec2: {:?}", vec, vec2);

//输出结果：
  按元素下标切分为2 vec: [1, 1] vec2: [1, 2, 3]

//比较大小值
// max() 方法
// min() 方法

let mut vec1 = vec![1, 1, 1, 1, 1];
let mut vec2 = vec![1, 1, 1, 4];
let mut vec3 = vec1.max(vec2);
println!("比较最大值，返回有最大值的vec： {:?}", vec3);

let mut vec4 = vec![1, 1, 1, 1]
let mut vec5 = vec4.min(vec3);
println!("比较最大值，返回有最小值的vec：{:?}", vec5);

//输出结果：
 比较最大值，返回有最大值的vec：[1, 1, 1, 4]
 比较最大值，返回有最小值的vec：[1, 1, 1, 1]

// filter() 方法：条件过滤

let vec = vec![1, 2, 3];
let new_vec: Vec<i32> = vec.into_iter().filter(|x| *x > 1).collect();
assert_eq!(new_vec, [2, 3])

还有as_slice()，last()， first()，insert()等方法