Rust中向量的学习笔记

let mut vec_number: Vec<i32> = Vec::new();

fn main() {
    // 创建一个整数向量
    let vec_number: Vec<i32> = vec![66, 99, 100];
    println!("{:?}", vec_number);

    // 创建一个字符串向量
    let vec_str: Vec<String> = vec!["CSDN".to_string(), "GitHub".to_string()];
    println!("{:?}", vec_str);
}

fn main() {
    let vec_number: Vec<i32> = vec![0; 5];
    // 输出：[0, 0, 0, 0, 0]
    println!("{:?}", vec_number);
}

fn main() {
    // 创建一个初始为空，但足够存储5个整型元素的向量
    let mut vec_number: Vec<i32> = Vec::with_capacity(5);
    // 输出：[]
    println!("{:?}", vec_number);
}

fn main() {
    let mut vec_number = vec![66, 99, 100];
    // 访问第一个元素，输出：66
    println!("{}", vec_number[0]);
    // 修改第二个元素
    vec_number[2] = 88;

    // 安全访问，当索引不存在时，不会panic
    if let Some(value) = vec_number.get(2) {
        // 输出：88
        println!("{}", value);
    } else {
        println!("out of bounds");
    }

    // 对可变引用的安全访问，可修改向量中的元素
    let mut vec_mut = vec![1, 2, 3];
    if let Some(value) = vec_mut.get_mut(1) {
        *value = 1024;
    }

    // 输出：[1, 1024, 3]
    println!("{:?}", vec_mut);
    
    // 获取向量的长度，输出：3
    println!("{}", vec_mut.len());
    // 清空向量，并判断向量是否为空
    vec_mut.clear();
    if vec_mut.is_empty() {
        println!("empty");
    } else {
        println!("not empty");
    }
}

fn main() {
    let mut vec_str = vec!["CSDN", "GitHub", "Gitee"];

    // 使用for循环遍历向量的所有元素
    for s in &vec_str {
        println!("{}", s);
    }
    
    // 使用iter()显式获取迭代器
    for s in vec_str.iter() {
        println!("{}", s);
    }
    
    // 若要修改元素，需使用iter_mut()获得可变引用迭代器
    for s in vec_str.iter_mut() {
        if s.starts_with("C") {
            *s = "Rust";
        }
    }

    println!("{:?}", vec_str);
    
    for s in vec_str.into_iter() {
        println!("{}", s);
    }
    // 到这里时，vec_str不再有效，因为它已经被消耗掉了
    // println!("{:?}", vec_str);
}

fn main() {
    let mut vec_number = vec![10, 20];
    vec_number.push(66);
    // 输出：[10, 20, 66]
    println!("{:?}", vec_number);

    let last_number = vec_number.pop();
    // 输出：66
    if let Some(value) = last_number {
        println!("{}", value);
    } else {
        println!("no data");
    }
    
    // 输出：[10, 20]
    println!("{:?}", vec_number);
}

fn main() {
    let mut vec_number = vec![10, 20];
    // 插入元素
    vec_number.insert(1, 66);
    // 输出：[10, 66, 20]
    println!("{:?}", vec_number);

    // 删除元素
    vec_number.remove(0);
    // 输出：[66, 20]
    println!("{:?}", vec_number);
}

fn main() {
    let mut vec_number = vec![10, 20, 30, 40, 50];

    // 获取一个切片，从索引2到4（不包括4）
    let slice = &mut vec_number[2..4];
    // 输出：[30, 40]
    println!("{:?}", slice);

    // 修改切片中的元素
    for item in slice.iter_mut() {
        *item *= 2;
    }

    // 输出：[60, 80]
    println!("{:?}", slice);
}

fn main() {
    let mut vec_number = vec![7, 88, 12, 36, 50];

    // 默认为升序排序
    vec_number.sort_unstable(); 
    // 输出：[7, 12, 36, 50, 88]
    println!("{:?}", vec_number);

    // 显式指定排序规则，仍然是升序
    vec_number.sort_by(|a, b| a.cmp(b));

    // 输出: [7, 12, 36, 50, 88]
    println!("{:?}", vec_number);

    // 若要降序排序，反转比较结果
    vec_number.sort_unstable_by(|a, b| b.cmp(a));
    // 输出: [88, 50, 36, 12, 7]
    println!("{:?}", vec_number);
}

fn main() {
    let mut vec_number = vec![10, 20, 30];
    // 向量为[10, 20, 30, 0, 0]，大小为5，容量可能增长以容纳更多元素
    vec_number.resize(5, 0);
    println!("{:?}", vec_number);

    // 向量为[10, 20]，大小为2，但容量可能仍然大于2
    vec_number.resize(2, 0);
    println!("{:?}", vec_number);
}

fn main() {
    let mut vec_number = vec![10, 20, 30];
    // 确保vec至少有20的容量，但不改变其大小和内容
    vec_number.reserve(20);
    // 输出：[10, 20, 30]
    println!("{:?}", vec_number);
}

fn main() {
    let mut vec_number = vec![10, 20, 30];
    // 将容量增加到10
    vec_number.reserve(10);
    // 删除一个元素，现在大小是2，但容量可能仍然是10
    vec_number.pop();
    // 尝试将容量减少到2
    vec_number.shrink_to_fit();
    println!("{}", vec_number.capacity());
}

fn main() {
    let mut vec1 = vec![1, 2, 3];
    let vec2 = vec![4, 5, 6];
    
    // 将vec2的内容添加到vec1末尾
    vec1.extend(vec2);
    // 输出：[1, 2, 3, 4, 5, 6]
    println!("{:?}", vec1);
    // vec2被extend函数转移了所有权，到这里时无效了
    // println!("{:?}", vec2);
    
    // 创建一个新的向量来包含两个向量的内容
    let vec3 = vec![1, 2, 3];
    let vec4 = vec![4, 5, 6];
    let vec5: Vec<i32> = vec3.into_iter().chain(vec4).collect();
    // 输出：[1, 2, 3, 4, 5, 6]
    println!("{:?}", vec5);
}