动态数组答应你存储多个值，这些值在内存中一个紧挨着另一个排列，因而拜访其间某个元素的本钱非常低。动态数组只能存储相同类型的元素，假如你想存储不同类型的元素，能够运用之前讲过的枚举类型或者特征目标。

创立动态数组

在 Rust 中，有多种办法能够创立动态数组。

Vec::new

运用 Vec::new 创立动态数组是最 rusty 的办法，它调用了 Vec 中的 new 关联函数：

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

这儿，v 被显式地声明晰类型 Vec，这是由于 Rust 编译器无法从 Vec::new() 中得到任何关于类型的暗示信息，因而也无法推导出 v 的具体类型，可是当你向里边添加一个元素后，一切又不同了：

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

此时，v 就无需手动声明类型，由于编译器经过 v.push(1)，推测出 v 中的元素类型是 i32，因而推导出 v 的类型是 Vec。

vec![]

还能够运用宏 vec! 来创立数组，与 Vec::new 有所不同，前者能在创立一起给予初始化值：

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

同样，此处的 v 也无需标注类型，编译器只需查看它内部的元素即可主动推导出 v 的类型是 Vec。

从 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!("去你的第三个元素，根本没有！"),
}

和其它语言一样，集合类型的索引下标都是从 0 开始，&v[2] 表明借用 v 中的第三个元素，最终会获得该元素的引证。而 v.get(2) 也是拜访第三个元素，可是有所不同的是，它回来了 Option<&T>，因而还需求额定的 match 来匹配解构出具体的值。

下标索引与.get的区别

这两种办法都能成功的读取到指定的数组元素，既然如此为什么会存在两种办法？况且 .get 还会添加运用复杂度，这就涉及到数组越界的问题了，让咱们经过示例说明：

let v = vec![1, 2, 3, 4, 5];
let does_not_exist = &v[100];
let does_not_exist = v.get(100);

运转以上代码，&v[100] 的拜访办法会导致程序无情报错退出，由于发生了数组越界拜访。 可是 v.get 就不会，它在内部做了处理，有值的时候回来 Some(T)，无值的时候回来 None，因而 v.get 的运用办法非常安全。

迭代遍历 Vector 中的元素

假如想要顺次拜访数组中的元素，能够运用迭代的办法去遍历数组，这种办法比用下标的办法去遍历数组更安全也更高效（每次下标拜访都会触发数组鸿沟查看）：

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

也能够在迭代过程中，修改 Vector 中的元素：

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

存储不同类型的元素

在本节最初，有讲到数组的元素有必要类型相同，可是也提到了解决方案：那就是经过运用枚举类型和特征目标来完成不同类型元素的存储。先来看看经过枚举怎么完成：

use crate::IpAddr::IpV6;
#[derive(Debug)]
enum IpAddr{
    IpV4(String),
    IpV6(String)
}
fn main() {
    let v = vec![
        IpAddr::IpV4("192.168.0.1".to_string()),
        IpV6("::1".to_string())
    ];
    for ip in v {
        println!("{:?}", ip)
    }
}

数组 v 中存储了两种不同的 ip 地址，可是这两种都属于 IpAddr 枚举类型的成员，因而能够存储在数组中。

再来看看特征目标的完成：

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();
    }
}

比枚举完成要稍微复杂一些，咱们为 V4 和 V6 都完成了特征 IpAddr，然后将它俩的实例用 Box::new 包裹后，存在了数组 v 中，需求注意的是，这儿有必要手动地指定类型：Vec<Box>，表明数组 v 存储的是特征 IpAddr 的目标，这样就完成了在数组中存储不同的类型。

在实际运用场景中，特征目标数组要比枚举数组常见许多，主要原因在于特征目标非常灵敏，而编译器对枚举的限制较多，且无法动态添加类型。

Vector 的排序

在 rust 里，完成了两种排序算法，分别为安稳的排序 sort 和 sort_by，以及非安稳排序 sort_unstable 和 sort_unstable_by。

当然，这个所谓的 非安稳 并不是指排序算法本身不安稳，而是指在排序过程中对相等元素的处理办法。在 安稳 排序算法里，对相等的元素，不会对其进行从头排序。而在 不安稳 的算法里则不保证这点。

总体而言，非安稳 排序的算法的速度会优于 安稳 排序算法，一起，安稳 排序还会额定分配原数组一半的空间。

整数数组的排序

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

浮点数数组的排序

在浮点数当中，存在一个 NAN 的值，这个值无法与其他的浮点数进行对比，因而，浮点数类型并没有完成全数值可比较 Ord 的特性，而是完成了部分可比较的特性 PartialOrd。

如此，假如咱们确定在咱们的浮点数数组当中，不包括 NAN 值，那么咱们能够运用 partial_cmp 来作为大小判别的依据。

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, Ord, Eq, PartialEq, PartialOrd)]
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("Al".to_string(), 30),
        Person::new("John".to_string(), 1),
        Person::new("John".to_string(), 25),
    ];
    people.sort_unstable();
    println!("{:?}", people);
}

需求 derive Ord 相关特性，需求保证你的结构体中所有的特点均完成了 Ord 相关特性，否则会发生编译错误。derive 的默认完成会依据特点的顺序顺次进行比较，如上述例子中，当 Person 的 name 值相同，则会运用 age 进行比较。