Rust基础(6)-vector、String、hashmap

vector、String、hashmap

vector

1. 创建空的vector: Vet
2. 创建包含初始值的vector
3. 丢弃vector
4. 读取元素
5. 更新
6. 遍历
7. 使用枚举
8. 补充：不可变引用之后使用了可变引用，则不能再使用原先不可变引用

fn main() {
    //1. 创建空的vector:  Vet<T>
    let mut v: Vec<i32> = Vec::new();
    // v.push(1);

    // 2. 创建包含初始值的vector
    let v = vec![1, 2, 3];

    // 3. 丢弃vector
    {
        let v1 = vec![1, 2, 3];
    }

    // 4. 读取元素
    let one: &i32 = &v[0];
    println!("one = {}", one);
    println!("one = {}", *one);

    //推荐使用的方式
    match v.get(1){
        Some(value)=>println!("value = {}", value),
        _=>println!("do noting"),
    }

    //5. 更新
    let mut v2:Vec<i32> = Vec::new();
    v2.push(1);
    v2.push(3);
    v2.push(2);

    // 6. 遍历
    // 6.1 不可变遍历
    for i in &v2  {
        println!("i = {}",i);
    }
    // 6.2 可变遍历
    for i in &mut v2  {
        *i +=1;
        println!("i = {}",i);
    }

    // 7. 使用枚举
    enum Context{
        Text(String),
        Float(f32),
        Int(i32),
    };
    let c = vec![
        Context::Text(String::from("string")),
        Context::Int(-1),
        Context::Float(0.001)
    ];

    //8. 补充
    let mut v = vec![1,2,3,4,5];
    let first = &v[0];  //不可变引用
    v.push(6);  //可变引用
    println!("first = {}",first)  //此时使用不可变引用，会报错
}

String

1. 创建一个空String
2. 通过字面值创建一个String
   1. 使用String::from()
   2. 使用str的方式
3. 更新String
   1. push_str
   2. push
   3. 使用"+"合并字符串
   4. 使用format
4. String索引
5. str索引
6. 遍历
   1. chars
   2. bytes

fn main() {
    //1. 创建一个空String
    let mut s0 = String::new();
    s0.push_str("hello");
    println!("s0 = {}", s0);
    // 2. 通过字面值创建一个String
    //    1. 使用String::from()
    //    2. 使用str的方式
    let s1 = String::from("init some thing");
    println!("s1 = {}", s1);
    let s1 = "init some thing".to_string();
    println!("s1 = {}", s1);
    // 3. 更新String
    //    1. push_str
    //    2. push
    //    3. 使用"+"合并字符串
    //    4. 使用format
    let mut s2 = String::from("hello");
    s2.push_str(", world");
    let ss = " !".to_string();
    s2.push_str(&ss);
    println!("{}", s2);

    let mut s2 = String::from("tea");
    s2.push('m');  //push只能添加一个字符
    //s2.push('mms');  //push只能添加一个字符
    println!("{}", s2);

    let s1 = "hello".to_string();
    let s2 = String::from(", world");
    let s3 = s1 + &s2;
    // println!("s1 = {}",s1); //s1不能再使用
    println!("s3 = {}", s3);
    println!("s2 = {}", s2);

    let s341 = String::from("tic");
    let s342 = String::from("tac");
    let s343 = String::from("toe");
    let s344 = format!("{}-{}-{}", s341, s342, s343);
    println!("s344 = {}", s344);
    println!("s341 = {}", s341);
    println!("s342 = {}", s342);
    println!("s343 = {}", s343);

    // 4. String索引
    let s4 = String::from("你好");
    // lets41 = s4[0];  //错误，String不能被索引，因为使用的utf8编码，不能逐个索引，无法解析

    //slice方式可以索引
    let hello = "你好";
    let h5 = &hello[0..3];  //边界要取对，否则解析依旧异常
    println!("h5 = {}", h5);

    // 5. str索引
    //同上
    // 6. 遍历
    //    1. chars
    //    2. bytes
    //chars
    for c in s4.chars(){
        println!("c = {}", c);
    }
    //byte
    for b in s4.bytes(){
        println!("b = {}", b);
    }
}

HashMap

1. 引入：use std::collections::HashMap;
2. HashMap<K,V>
3. 创建HashMap
4. 读取
5. 遍历
6. 更新

use std::collections::HashMap;
fn main() {
    //3. 创建HashMap
    let mut scores: HashMap<String, i32> = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Red"), 20);
    println!("Hello, world!");

    //使用vector创建
    let keys = vec![String::from("Blue"), String::from("Red")];
    let values = vec![10, 20];
    let scores: HashMap<_, _> = keys.iter().zip(values.iter()).collect();

    //读取
    let k = String::from("Blue");
    if let Some(v) = scores.get(&k) {// v = 10; 返回的是Option
        println!("v = {}", v);
    }

    let v = scores.get(&k);
    match v{
        Some(value) => println!("v = {}",value),
        None => println!("None"),
    }

    //遍历，会以任意的顺序遍历
    for (key,value) in &scores{
        println!("{},{}",key,value);
    }

    //直接插入值
    let mut ss = HashMap::new();
    ss.insert(String::from("one"),1);
    ss.insert(String::from("two"),2);
    ss.insert(String::from("three"),3);
    ss.insert(String::from("one"),4);
    //键值不存在才插入
    ss.entry(String::from("two")).or_insert(3);
    println!("{:?}",ss);

    //根据旧值来更新一个值
    let text = "hello world wonderful world";
    let mut map = HashMap::new();
    for word in text.split_whitespace(){
        let count = map.entry(word).or_insert(0);
        *count +=1;
    }
    println!("map = {:?}",map)
}

总结

已编辑完毕

参考

[1] Rust 程序设计语言