rust Vec 常用操作

目录

Vec  

声明

判空

循环遍历带下标和值

循环遍历输出

循环遍历修改

追加

删除

修改

排序-整数排序

搜索

转换

条件筛选

调整大小

比较两个vec元素的最大值

条件过滤


 

 

Vec  

      一种连续的可增长数组类型,写为 Vec ,读作 vector 。堆分配内容,连续可增长,有序的数组类型分配的字节数永远不会超过  isize :: MAX 字节。
只能储存相同类型的值,但其存储类型可以自定义

 

声明

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

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

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

    let mut vec = vec![1, 5, 10, 2, 15];
    println!("  用宏声明Vec时赋值 {:?}  , 长度  {} ", vec, vec.len());

console:

    声明一个空Vec []  , 长度  0 
    声明一个重复元素的Vec: [1, 1, 1, 1, 1]
    声明一个初始长度为10的Vec: {:?} , 长度  len 0  capacity 10
    用宏声明Vec时赋值 [1, 5, 10, 2, 15]  , 长度  5 

 

判空

    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());
 
console:

    Vec是否为空 :false, 元素0 :false

 

循环遍历带下标和值

    let v = vec!['a', 'b', 'c']; 
    for (index, value) in v.iter().enumerate() {
        println!("{} is at index {}", value, index);
    }

 

循环遍历输出

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

    print!("&v        ");
    for x in &v {
        print!("{} ", x);
    }
    println!(" ");
    print!("len  get  ");
    for x in 0..v.len() {
        if let Some(num) = v.get(x) {
            print!("{} ", num);
        }
    }
    println!(" ");
    print!("iter      ");
    for x in v.iter() {
        print!("{} ", x);
    }
    println!(" ");
    print!("into_iter ");
    for x in v.into_iter() {
        print!("{} ", x);
    }
    println!(" ");

console:

    &v        1 2 3  
    len  get  1 2 3  
    iter      1 2 3  
    into_iter 1 2 3 

循环遍历修改

    let mut v1 = vec![1, 2, 3];
    for x in &mut v1 {
        *x += 1;
    }
    println!("&mut v1                   {:?}", v1);
    for x in v1.iter_mut() {
        *x += 1;
    }
    println!("v1.iter_mut               {:?}", v1);
    for x in 0..v1.len() {
        if let Some(num) = v1.get_mut(x) {
            *num += 1;
        }
    }
    println!("0..v1.len()  get_mut      {:?}", v1);
    let v2: Vec = v1.iter().map(|x| x + 1).collect();
    println!("v1.iter().map().collect() {:?}", v2);

console:

    &mut v1                   [2, 3, 4]
    v1.iter_mut               [3, 4, 5]
    0..v1.len()  get_mut      [4, 5, 6]
    v1.iter().map().collect() [5, 6, 7]

 

追加

    let mut vec = vec![1, 5];
    vec.push(13); //追加到末尾
    println!("  追加一个元素到末尾: {:?}", vec);
    vec.extend([1, 2, 3].iter().copied()); //追加到末尾
    println!("  追加一组元素到末尾: {:?}", vec);
    let mut vec5 = [1].repeat(2);
    vec.append(&mut vec5);
    println!("  追加一组元素到末尾: {:?}", vec);
    
console:
    
    追加一个元素到末尾: [1, 5, 13]
    追加一组元素到末尾: [1, 5, 13, 1, 2, 3]
    追加一组元素到末尾: [1, 5, 13, 1, 2, 3, 1, 1]  

 

删除


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

console:
    
    删除末尾的元素: [1, 5] , 长度  2
    删除末尾的元素: [1] , 长度  1

 

修改

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

console:
    
    第一个元素被修改 [2, 5, 6]

排序-整数排序

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

console:
        
    排序前: [1, 9, 6]
    排序后: [1, 6, 9]

搜索

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

console:
        
    是否有元素 [1, 9, 6]:true

转换

    //数组转Vec
    let array: [i32; 3] = [10, 40, 30];
    let vec: Vec = array.to_vec();
    let vec1: Vec = array.iter().cloned().collect();

条件筛选

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

console:

    条件筛选,只留下能整除2的 [2, 4]  , 长度  2

调整大小

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

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

console:

    new_len小于len,截断 [1, 2]
    new_len大于len,按差值进行扩展 [1, 2, 0, 0]
    按元素下标切分为2 vec: [1, 1] , vec2: [1, 2, 3]

 

比较两个vec元素的最大值

    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 vec1 = vec![1, 1, 1, 1, 1];
    let mut vec4 = vec1.min(vec3);
    println!("  比较最大值,返回有最小值的vec: {:?}", vec4);

console:

    比较最大值,返回有最大值的vec: [1, 1, 1, 4]
    比较最大值,返回有最大值的vec: [1, 1, 1, 1, 1]

 

条件过滤

filter 迭代器适配器和捕获环境的闭包的用例。迭代器的 filter 方法获取一个使用迭代器的每一个项并返回布尔值的闭包。
闭包返回 true,包含在迭代器中;返回 false,不会包含在迭代器。
    let vec = vec![1, 2, 3];
    let new_vec: Vec = vec.into_iter().filter(|x| *x > 1).collect();
    assert_eq!(new_vec, [2, 3])

 

 

你可能感兴趣的:(rust,rust,vec)