一、动态数组是什么，怎么用

1、动态数组Vector是什么

动态数组类型用 Vec 表示，可以看成java的集合吧，和Golang的切片还是有点区别。

动态数组允许你存储多个值，顺序存储，访问效率高，但是只能存储相同类型的元素。

其实如果你想放不同类型的数据，可以考虑枚举或者特征对象

2、动态数组怎么用

（1）创建动态数组

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

或者

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

或者

let v = Vec::from([1,2,3]);

（2）尾部追加元素

let mut v = Vec::new();
v.push(1);

（3）尾部删除元素

fn main() {
    // 填空
    let arr = [1, 2, 3];
    let mut v = Vec::from(arr);
    let end:Option<i32>=v.pop();//会返回弹出的值
}

（4）删除指定位置元素

let mut v =  vec![1, 2];
assert!(!v.is_empty());         // 检查 v 是否为空

v.insert(2, 3);                 // 在指定索引插入数据，索引值不能大于 v 的长度， v: [1, 2, 3] 
assert_eq!(v.remove(1), 2);     // 移除指定位置的元素并返回, v: [1, 3]

（5）清除所有元素

v.clear();

（6）遍历所有元素和遍历并修改元素

let v = vec![1, 2, 3];
for i in &v {//注意要是借用，不然v就会丢失所有权。
    println!("{i}");
}

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

（7）读取Vector元素

分为下标访问和get访问

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

let third: &i32 = &v[2];
println!("第三个元素是 {}", third);

match v.get(2) {
    Some(third) => println!("第三个元素是 {third}"),
    None => println!("去你的第三个元素，根本没有！"),
}
//模式匹配也可以写成if let
if let Some(third) = v.get(2) {
        println!("第三个元素是 {third}");
} else {
        println!("去你的第三个元素，根本没有！");
}

v.get(2) 也是访问第三个元素，但是有所不同的是，它返回了 Option<&T>，因此还需要额外的 match 来匹配解构出具体的值。

从安全性出发，get更安全，get在内部做了处理，有值的时候返回 Some(T)，无值的时候返回 None，因此 v.get 的使用方式非常安全。

（8）Vector整体和内部的某个元素，需要遵守借用规则

哪怕只是拿了某个元素的可变引用，也不能再获得Vector整体的不可变引用

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

let first = &v[0];

v.push(6);

println!("The first element is: {first}");

（9）Vector存储不同类型的数据

如果是特征对象，得保证不同类型都实现了相同特征

trait IpAddr {
    fn display(&self);
}

struct V4(String);
impl IpAddr for V4 {
    fn display(&self) {
        println!("ipv4: {:?}",self.0)
    }
}
struct V6(String);
impl IpAddr for V6 {
    fn display(&self) {
        println!("ipv6: {:?}",self.0)
    }
}

fn main() {
    let v: Vec<Box<dyn IpAddr>> = vec![
        Box::new(V4("127.0.0.1".to_string())),
        Box::new(V6("::1".to_string())),
    ];

    for ip in v {
        ip.display();
    }
}

（10）Vector排序

整数数组排序

fn main() {
    let mut vec = vec![1, 5, 10, 2, 15];    
    vec.sort_unstable();    
    assert_eq!(vec, vec![1, 2, 5, 10, 15]);
}

浮点数排序

fn main() {
    let mut vec = vec![1.0, 5.6, 10.3, 2.0, 15f32];    
    vec.sort_unstable_by(|a, b| a.partial_cmp(b).unwrap());    
    assert_eq!(vec, vec![1.0, 2.0, 5.6, 10.3, 15f32]);
}

结构体排序
能比较的前提是，结构体字段实现了排序比较相关的特征，如果不想自己写，可以使用派生的比较特征

#[derive(Debug)]
struct Person {
    name: String,
    age: u32,
}

impl Person {
    fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }
}

fn main() {
    let mut people = vec![
        Person::new("Zoe".to_string(), 25),
        Person::new("Al".to_string(), 60),
        Person::new("John".to_string(), 1),
    ];
    // 定义一个按照年龄倒序排序的对比函数
    people.sort_unstable_by(|a, b| b.age.cmp(&a.age));

    println!("{:?}", people);
}

（11）字符串转Vector

    let s = "hello".to_string();
    let v1: Vec<u8> = s.into();

    let s = "hello".to_string();
    let v2 = s.into_bytes();