Rust Vec＜T＞

创建空向量

let mut numbers : Vec<i32> = vec![];

创建给定内容的向量

	let mut words = vec!["apple","red","yellow"];
    let mut buffer = vec![0i32;1024];//1024个填充0的字节
    println!("words:{:?}",words);
    let my_vec = words.into_iter().collect::<Vec<&str>>();
    

访问元素

    let mut words = vec!["apple","red","yellow"];
    
   //取得一个元素的引用
    let first_world = &words[0];	
    println!("first_world: {}",first_world);
    
    //取得一个元素的副本   
    let  numbers = vec![1,2,3,5];
    let copy_num = numbers[0];
    let second_word = words[1].clone();
    println!("copy_num: {}",copy_num);
    println!("second_world :{}",second_world );
    
    //取得一个切片的引用
    let my_ref = &words[0..2];
    println!("my_ref:{:?}",my_ref);
    
    //取得一个切片的副本
    let my_copy = words[0..2].to_vec(); //要求Clone
    println!("my_copy:{:?}",my_ref);

常用的可用于向量、切片、数组的方法

  //常用的向量方法
    //first()
    if let Some(item) = words.first(){
        println!("Some(item) : {}",item);
    }
    //last(),同上，返回的是最后一个元素的引用
    //get(index)    
    if let Some(item) = words.get(2){
        println!("get(index):{}",item);
    }
// first_mut(), last_mut(), get_mut(index),上面几个方法的变体，返回的是元素的引用，一般用这种_mut的方法较多
   let mut atde = vec!["a","b","c","d"];
   //let aed = atde.first_mut().unwrap();
   if let Some(item) = atde.first_mut(){
       println!("aed:{}",item);
   }   
   //to_vec(),克隆整个切片，返回一个新的向量
   let a2 = vec!["length","width","height"];
   let b2 = a2.to_vec();
   println!("a2:{:?}",a2);
   println!("b2:{:?}",b2);

使用[…] 与to_vec()方法创建某个切片一部分元素并且拥有其所有权的新向量

   let a3 = vec!["max","maya","Zbrush","Blender","Rhino","Fusion 360","Photoshop","Ai","Keyshop"];
   let b3 = a3[0..6].to_vec();
   println!("a3:{:?}\nb3:{:?}",a3,b3);

向量的迭代

   let mut a3 = vec!["max","maya","Zbrush","Blender","Rhino","Fusion 360","Photoshop","Ai","Keyshop"];
  let b3 = a3[0..6].to_vec();
//iter()
  println!("================================);
  for b in b3.iter(){
      println!("{}",b);
  }
//iter_mut()
println!("==================================");
  for a in a3.iter_mut(){
      println!("{}",a);
  }

增长或者收缩向量

	//slice.len()		获取向量的长度，返回类型为usize
	//slice.is_empty()			向量是否为空，相当于slice.len(),为空是返回True
	let vec =vec![1,23,4,5,66];

vec.push(value) 与 vec.pop()

	
	//在vec的末尾添加给定的值value
	vec.push(7);
	//移除并返回向量vec的最后一个值，返回的是Option<T>,如果向量为空则返回None，注意push(),pop()返回的是参数的值而不是引用。			
	//vec.pop();	
	let mut vec = vec![1,2,34,5,6];
    vec.push(8);
    println!("vec_2:{:?}",vec);

    if let Some(vec_2) = vec.pop(){
        println!("{:?}",vec_2);
    }
    }

vec.insert(index, value) 与 vec.remove(index)

vec.insert(index,value) 在vec[Index]位置插入value
vec.remove(index); 移动vec[index]的值

let mut vec = vec![1,2,34,5,6];
vec.insert(2,333);
vec.remove(0);

将向量的长度修改为指定的值

//将向量的长度设置为new_len，如果vec的长度增加了，则将value的副本放到新位置。这个value元素必须是衧了Clone 特型。
vec.resize(new_len,value);
//将vec的长度减少为new_len，也就是说将vec[new_len..]范围内的数据清除
vec.truncate(new_len);

//从vec中移除所有元素，相当于vec.truncate(0);
vec.clear();

vec.extend(vec2)

会将vec2的所有权移动到该方法里去，调用这个方法后，vec2将不能再继续使用

let mut a = vec!["a"];
let b = vec!["b"];
let c = vec!["c"];
 a.extend(b);
 //错误，不能再调用b
//println!("{:?}",b);
println!("{:?}",a);

//如果不想失去所有权，可以使用&借用的形式来用这个extend
a.extend(&c);
println!("{:?}",c);
println!("{:?}",a);

vec.append(& mut vec2)

这个方法传入的是vec的可变引用，调用完这个方法后，vec2将被清空为[]

let mut a = vec!["A","B","C"];
let mut b = vec!["D","F","G"];
a.append(&mut b);
println!("{:?}",a);
println!("{:?}",b);

运行结果：

["A", "B", "C", "D", "F", "G"]
[]

运行结束，执行耗时：1毫秒