use std::collections::HashMap;

fn main() {
    // 初始化
    // 1 使用new
    let v1: Vec<i32> = Vec::new();

    // 2 使用初始值创建vec<T>,使用vec!宏 
    let v2 = vec![1,2,3];

    // 更新
    let mut v3 = Vec::new();

    v3.push(1);
    v3.push(2);
    v3.push(3);
    v3.push(4);

    // 删除
    // 离开作用域自动清理
    {
        let v4 = vec![1,2,3];
    }

    // 读取
    let v5 = vec![1,2,3];
    // 第一种 索引
    println!("the third elements is {}", v5[2]);

    // 第二种 get方法
    match v5.get(2) {
        Some(third) => println!("the third elements is {}", third),
        None => println!("there is no third element"),
    }  

    // 所有权和借用规则
    let mut v6 = vec![1,2,3];
    // 不可变借用
    let first = &v6[0];
    // 可变借用
    // v6.push(4); // 报错 不能把v6作为可变借用，因为其已经作为不可变借用
    println!("the third elements is {}", first); // 不可变借用

    // 遍历
    let mut v7 = vec![1,2,3];
    for i in &v7 {
        println!("{}", i);
    }

    // enum + Vector存储不同类型的值
    enum SpreadsheeCell {
        Int(i32),
        Float(f64),
        Text(String)
    }

    let row = vec![
        SpreadsheeCell::Int(3),
        SpreadsheeCell::Text(String::from("blue")),
        SpreadsheeCell::Float(10.12)
    ];

    // String
    // 创建
    // 空字符串
    let mut s1 = String::new();
    // 使用初始值创建
    // to_string方法，可用于实现了Display trait的类型，包括字符串字面量
    let s2 = "value".to_string();
    // 从字面量创建String
    let s3 = String::from("value");


    // 更新
    let mut s4 = String::from("first");

    // push_str: 把一个字符串切片附加到String
    s4.push_str(" second");
    println!("{}", s4);

    // push: 把单个字符附加到String
    s4.push(',');
    println!("{}", s4);

    // + 连接字符串
    let s51 = String::from("one ");
    let s52 = String::from("two ");
    let s53 = s51 + &s52;

    println!("{}", s53);

    // format!: 连接多个字符串
    let s6 = format!("{}-{}-{}", String::from("tic"), String::from("tac"), String::from("toe"));
    println!("{}", s6);

    // 遍历
    let s7 = String::from("value");
    // 遍历字节（Bytes）
    for b in s7.bytes() {
        println!("{}", b);
    }
    // 遍历字符（Scalar Values）
    for b in s7.chars() {
        println!("{}", b);
    }

    // 切割string
    let s8 = String::from("hello,world!");
    println!("{}", &s8[..3]);



    // hashmap<K, V>
    // 创建空的HashMap
    let mut h1: HashMap<&str, &str> = HashMap::new();
    h1.insert("cat", "lyl");

    // collect方法
    // 在元素类型为Tuple的Vector上使用collect方法，可以组建一个hashmap
    // - 要求Tuple有两个值：一个作为K，一个作为V
    // - collect方法可以把数据整合成很多种集合类型，包括hashmap
    //   - 返回值需要显式指明类型
    let teams = vec![String::from("red"),String::from("yellow")];
    let initial_scores = vec![88,90];

    let scores: HashMap<&String, &i32> = teams.iter().zip(initial_scores.iter()).collect();

    // 所有权
    let field_name = String::from("Favorite color");
    let field_value = String::from("red");

    let mut h2 = HashMap::new();
    h2.insert(field_name, field_value);

    // println!("{}:{}", field_name, field_value); // 报错，已失效


    // 访问
    let mut h3 = HashMap::new();
    h3.insert(String::from("red"), 10);
    h3.insert(String::from("green"), 88);

    let score = h3.get("red");
    match score {
        Some(s) => println!("{}", s),
        None => println!("not found!"),
    }
 
    // 遍历
    let mut h4 = HashMap::new();
    h4.insert(String::from("red"), 10);
    h4.insert(String::from("green"), 88);

    for (k, v) in h4 {
        println!("{}:{}", k, v);
    }

    // 更新
    // 替换现有的V
    let mut h5 = HashMap::new();
    h5.insert(String::from("red"), 10);
    h5.insert(String::from("red"), 20);

    println!("{:?}", h5);

    // 存在不插入，不存在插入
    // entry方法：检查指定的K是否对应一个V
    // Entry的or_insert方法
    //  - 如果存在，返回对应的V的一个可变引用
    //  - 如果不存在，将方法参数作为K的新值插进去，返回到这个值的可变引用 
    h5.entry(String::from("red")).or_insert(50);
    println!("{:?}", h5);

    // 基于现有值来更新V
    let text = "hello world wonderful world";

    let mut h6 = HashMap::new();

    for word in text.split_whitespace() {
        let count = h6.entry(word).or_insert(0);
        *count += 1;
    }

    println!("{:#?}", h6);
}