[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}