Rust: 컬렉션

개요

• 문서
• 힙에 저장
• 벡터
  • 여러 개의 값을 연속적으로 저장
  • 접근 방법
    • []
      • 유효하지 않은 인덱스 일 경우 panic 발생
    • get
      • Option<&T> 반환
      • 유효하지 않은 인덱스 일 경우 None 반환
  • 열거형을 이용하여 값마다 다른 타입 저장 가능
• 스트링
  • 문자의 모음
  • + 연산은 소유권을 가져감
  • format 매크로는 소유권을 가져가지 않음
• 해쉬맵
  • 어떤 값을 특정한 키와 연관

예제

• 코드

        use std::collections::HashMap;

        fn main() {
            {
                let v: Vec<i32> = Vec::new();
                println!("1 : {:?}", v);

                let mut v = Vec::new();
                v.push(1);
                v.push(2);
                v.push(3);
                println!("2.1 : {:?}", v);
                v.pop();
                println!("2.2 : {:?}", v);

                let v = vec![1, 2, 3];
                println!("3.1 : {}, {:?}, {:?}", v[1], v.get(1), v.get(100));
                for i in &v {
                    println!("3.2 : {}", i);
                }

                let mut v = vec![1, 2, 3];
                for i in &mut v {
                    *i += 1;
                }
                for i in &v {
                    println!("4 : {}", i);
                }

                #[derive(Debug)]
                enum Test {
                    A(i32),
                    B(String),
                }
                let mut v = Vec::new();
                v.push(Test::A(1));
                v.push(Test::B(String::from("a")));
                println!("5 : {:?}", v);
            }

            {
                let s = String::from("a");
                println!("6 : {}", s);

                let s = "a".to_string();
                println!("7 : {}", s);

                let s = 1.to_string();
                println!("8 : {}", s);

                let mut s = String::from("a");
                s.push('b');
                println!("9 : {}", s);

                let mut s = String::from("a");
                s.push_str(", b");
                println!("10 : {}", s);

                let mut s1 = String::from("a");
                let s2 = String::from("b");
                println!("11.1 : {}", format!("{}-{}", s1, s2));
                println!("11.2 : {}, {}", s1, s2);
                println!("11.3 : {}", s1.clone() + &s2);
                s1.push_str(&s2);
                println!("11.4 : {}, {}", s1, s2);

                let s = String::from("abc");
                println!("12 : {}", s.len());

                let s = String::from("abc");
                for byte in s.bytes() {
                    println!("13.1 : {}", byte);
                }
                for c in s.chars() {
                    println!("13.2 : {}", c);
                }
            }

            {
                let mut m = HashMap::new();
                m.insert(String::from("a"), 1);
                m.insert(String::from("b"), 2);
                println!("14.1 : {:?}", m);
                println!("14.2 : {:?}", m.get(&String::from("a")));
                println!("14.3 : {:?}", m.get(&String::from("c")));

                let key = vec![String::from("a"), String::from("b")];
                let value = vec![1, 2];
                let m: HashMap<_, _> = key.iter().zip(value.iter()).collect();
                println!("15 : {:?}", m);

                let mut m = HashMap::new();
                m.insert(String::from("a"), 1);
                m.insert(String::from("b"), 2);
                for (key, value) in &m {
                    println!("16 : {}-{}", key, value);
                }

                let mut m = HashMap::new();
                m.insert(String::from("a"), 1);
                println!("17.1 : {:?}", m);
                m.entry(String::from("a")).or_insert(2);
                println!("17.2 : {:?}", m);
                m.entry(String::from("b")).or_insert(2);
                println!("17.3 : {:?}", m);
                let value = m.entry(String::from("a")).or_insert(2);
                *value += 1;
                println!("17.4 : {:?}", m);
            }
        }

• 실행 결과

        1 : []
        2.1 : [1, 2, 3]
        2.2 : [1, 2]
        3.1 : 2, Some(2), None
        3.2 : 1
        3.2 : 2
        3.2 : 3
        4 : 2
        4 : 3
        4 : 4
        5 : [A(1), B("a")]
        6 : a
        7 : a
        8 : 1
        9 : ab
        10 : a, b
        11.1 : a-b
        11.2 : a, b
        11.3 : ab
        11.4 : ab, b
        12 : 3
        13.1 : 97
        13.1 : 98
        13.1 : 99
        13.2 : a
        13.2 : b
        13.2 : c
        14.1 : {"b": 2, "a": 1}
        14.2 : Some(1)
        14.3 : None
        15 : {"a": 1, "b": 2}
        16 : a-1
        16 : b-2
        17.1 : {"a": 1}
        17.2 : {"a": 1}
        17.3 : {"b": 2, "a": 1}
        17.4 : {"b": 2, "a": 2}