Rust 컬렉션 | Vec, HashMap, HashSet

Rust 컬렉션 | Vec, HashMap, HashSet

· 30분 읽기 · 수정 중급 튜토리얼
Rust 컬렉션 | Vec, HashMap, HashSet

이 글의 핵심

let mut v = vec![1, 2, 3, 4, 5];.

시리즈 안내

#06 | 📋 전체 목차 | 이전: #05 트레이트 · 다음: #07 동시성

들어가며

Vec·HashMap 등 컬렉션은 요소의 소유권을 어떻게 넣고 빼는지가 API마다 다릅니다. 열쇠를 넘기는지(push), 잠깐 빌려만 보는지(iter)를 구분하면 읽기 쉽습니다.

1. Vec (동적 배열)

기본 사용

fn main() {
    // 빈 벡터 생성
    let mut v: Vec<i32> = Vec::new();
    
    // 요소 추가
    v.push(1);
    v.push(2);
    v.push(3);
    
    println!("{:?}", v);  // [1, 2, 3]
    
    // 매크로로 생성
    let v = vec![1, 2, 3, 4, 5];
    
    // 인덱스 접근
    println!("{}", v[0]);  // 1
    
    // get으로 안전 접근
    match v.get(2) {
        Some(value) => println!("값: {}", value),
        None => println!("인덱스 초과"),
    }
    
    // 마지막 요소 제거
    let mut v = vec![1, 2, 3];
    let last = v.pop();
    println!("{:?}", last);  // Some(3)
}

Vec 메서드

let mut v = vec![1, 2, 3, 4, 5];
// 길이
println!("길이: {}", v.len());
// 비어있는지
println!("비어있음: {}", v.is_empty());
// 특정 인덱스에 삽입
v.insert(2, 10);  // [1, 2, 10, 3, 4, 5]
// 특정 인덱스 제거
v.remove(2);  // [1, 2, 3, 4, 5]
// 비우기
v.clear();
// 용량 관리
let mut v = Vec::with_capacity(10);
println!("용량: {}", v.capacity());

Vec 순회

let v = vec![1, 2, 3, 4, 5];
// 불변 참조
for item in &v {
    println!("{}", item);
}
// 가변 참조
let mut v = vec![1, 2, 3];
for item in &mut v {
    *item *= 2;
}
println!("{:?}", v);  // [2, 4, 6]
// 소유권 이동
for item in v {
    println!("{}", item);
}
// v는 더 이상 사용 불가

2. HashMap<K, V>

기본 사용

use std::collections::HashMap;
fn main() {
    let mut scores = HashMap::new();
    
    // 삽입
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Red"), 50);
    
    // 조회
    let team = String::from("Blue");
    let score = scores.get(&team);
    
    match score {
        Some(s) => println!("점수: {}", s),
        None => println!("팀 없음"),
    }
    
    // 기본값
    let score = scores.get("Green").unwrap_or(&0);
    println!("점수: {}", score);
}

HashMap 메서드

use std::collections::HashMap;
let mut map = HashMap::new();
map.insert("a", 1);
map.insert("b", 2);
// 존재 여부
if map.contains_key("a") {
    println!("a 있음");
}
// 없을 때만 삽입
map.entry("c").or_insert(3);
map.entry("a").or_insert(10);  // 무시됨
// 값 수정
let count = map.entry("a").or_insert(0);
*count += 1;
// 순회
for (key, value) in &map {
    println!("{}: {}", key, value);
}
// 삭제
map.remove("b");

3. HashSet

use std::collections::HashSet;
fn main() {
    let mut set = HashSet::new();
    
    // 추가
    set.insert(1);
    set.insert(2);
    set.insert(3);
    set.insert(1);  // 중복 무시
    
    println!("{:?}", set);  // {1, 2, 3}
    
    // 포함 여부
    if set.contains(&2) {
        println!("2 있음");
    }
    
    // 집합 연산
    let set1: HashSet<_> = [1, 2, 3].iter().cloned().collect();
    let set2: HashSet<_> = [2, 3, 4].iter().cloned().collect();
    
    // 합집합
    let union: HashSet<_> = set1.union(&set2).cloned().collect();
    println!("합집합: {:?}", union);  // {1, 2, 3, 4}
    
    // 교집합
    let intersection: HashSet<_> = set1.intersection(&set2).cloned().collect();
    println!("교집합: {:?}", intersection);  // {2, 3}
    
    // 차집합
    let difference: HashSet<_> = set1.difference(&set2).cloned().collect();
    println!("차집합: {:?}", difference);  // {1}
}

4. 반복자 (Iterator)

기본 반복자

let v = vec![1, 2, 3, 4, 5];
// iter: 불변 참조
let sum: i32 = v.iter().sum();
println!("합계: {}", sum);
// iter_mut: 가변 참조
let mut v = vec![1, 2, 3];
for item in v.iter_mut() {
    *item *= 2;
}
// into_iter: 소유권 이동
let v = vec![1, 2, 3];
let doubled: Vec<i32> = v.into_iter().map(|x| x * 2).collect();

반복자 메서드

let v = vec![1, 2, 3, 4, 5];
// map
let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();
// filter
let evens: Vec<i32> = v.iter().filter(|x| *x % 2 == 0).cloned().collect();
// fold (reduce)
let sum = v.iter().fold(0, |acc, x| acc + x);
// take
let first_three: Vec<i32> = v.iter().take(3).cloned().collect();
// skip
let skip_two: Vec<i32> = v.iter().skip(2).cloned().collect();
// enumerate
for (i, value) in v.iter().enumerate() {
    println!("{}: {}", i, value);
}

5. 실전 예제

예제: 단어 빈도 카운터

use std::collections::HashMap;
fn count_words(text: &str) -> HashMap<String, usize> {
    let mut counts = HashMap::new();
    
    for word in text.split_whitespace() {
        let word = word.to_lowercase();
        let count = counts.entry(word).or_insert(0);
        *count += 1;
    }
    
    counts
}
fn main() {
    let text = "hello world hello rust world world";
    let counts = count_words(text);
    
    for (word, count) in &counts {
        println!("{}: {}", word, count);
    }
}

6. Vec vs VecDeque vs LinkedList 성능 관점

컬렉션메모리인덱스 접근앞/뒤 삽입·삭제일반적인 선택
Vec연속 버퍼, 캐시 친화적O(1)뒤: O(1) 평균 / 앞: O(n)기본 선택
VecDeque링 버퍼(연속 블록)O(1)앞·뒤 O(1)큐, 양끝 작업
LinkedList노드 분산 할당O(n) 탐색알려진 노드 기준 삽입은 O(1)이지만 순회 비용이 큼Rust에서는 드묾
실무에서는 대부분 Vec 또는 VecDeque로 충분합니다. LinkedList는 이론상 중간 삽입이 빠르지만, 할당·캐시 미스 때문에 벤치마크에서 Vec가 이기는 경우가 많습니다. 앞쪽에서 자주 pop/insert해야 하면 Vec 대신 VecDeque를 검토하세요.
use std::collections::VecDeque;
let mut q = VecDeque::new();
q.push_back(1);
q.push_front(0);  // Vec에서는 비싼 작업

7. HashMap vs BTreeMap 선택 기준

기준HashMapBTreeMap
키 순서없음(해시 순서)키 정렬 순으로 순회
평균 조회/삽입O(1) 수준(해시)O(log n)
키 타입Hash + EqOrd
용도 예캐시, 카운터, 일반 룩업범위 쿼리, 정렬된 키 나열, “가장 가까운 키”
HashMap: 빠른 단일 키 조회가 목적일 때. BTreeMap: range(..)로 부분 구간 순회하거나, 디버깅 시 결정적인 순서가 필요할 때 유리합니다.
use std::collections::BTreeMap;
let mut m = BTreeMap::new();
m.insert(10, "a");
m.insert(20, "b");
for (k, v) in m.range(15..=25) {
    println!("{k} -> {v}");
}

8. Entry API 활용 (실전)

entry는 “키가 없으면 넣으며, 있으면 갱신”을 한 번의 해시 탐색으로 표현합니다. 앞서 단어 빈도 예제의 or_insert가 대표적입니다.

use std::collections::HashMap;
let mut map: HashMap<String, u32> = HashMap::new();
// 없을 때만 기본값 삽입
map.entry("key".into()).or_insert(0);
// 있으면 갱신, 없으면 새 값
map.entry("count".into())
    .and_modify(|c| *c += 1)
    .or_insert(1);
// 값을 계산해 넣기 (필요할 때만 비용 발생)
map.entry("expensive".into()).or_insert_with(|| {
    // 실제 코드에서는 여기서만 비싼 초기화를 수행
    42
});

or_insert/or_insert_with로 불필요한 할당·복사를 줄이며, and_modify로 가독성을 높일 수 있습니다.

9. 메모리 최적화: capacity, shrink_to_fit

  • Vec::with_capacity(n): push가 곧바로 재할당하지 않도록 미리 버퍼를 잡습니다. 크기를 대략 알 때 유효합니다.
  • len() vs capacity(): len은 요소 개수, capacity는 예약된 슬롯입니다. capacity - len이 곧 여유 공간입니다.
  • shrink_to_fit: 사용량이 줄어든 뒤 메모리를 OS에 반환하고 싶을 때 호출합니다. 매 호출마다 쓰기보다, 큰 맵/벡터를 비운 직후 등 구간에 쓰는 편이 낫습니다.
  • HashMap::shrink_to_fit: 해시 테이블도 마찬가지로, 요소가 많이 빠진 뒤에 고려합니다.
// 변수 선언 및 초기화
let mut v = Vec::with_capacity(1000);
for i in 0..10 {
    v.push(i);
}
v.shrink_to_fit(); // 실제 사용(10개)에 맞게 줄이기 시도

과도한 shrink_to_fit은 재할당 비용이 될 수 있으므로, 프로파일로 병목을 확인한 뒤 적용하는 것이 안전합니다.

정리

핵심 요약

  1. Vec: 동적 배열, push/pop
  2. HashMap: 키-값 저장, entry API
  3. HashSet: 중복 없는 집합
  4. 반복자: iter, map, filter, collect
  5. 소유권: iter(참조), into_iter(이동)
  6. Vec / VecDeque / LinkedList: 대부분 Vec·VecDeque; LinkedList는 특수한 경우만
  7. HashMap / BTreeMap: 속도 vs 정렬·범위 쿼리
  8. Entry: or_insert, and_modify, or_insert_with로 한 번에 처리
  9. 용량: with_capacity, shrink_to_fit은 실측 후 사용

다음 단계

관련 글

자주 묻는 질문 (FAQ)

Q. 이 내용을 실무에서 언제 쓰나요?

A. Rust 컬렉션 let mut v = vec![1, 2, 3, 4, 5];. 실전 예제와 코드로 개념부터 활용까지 정리합니다. Rust·컬렉션·Vec 중심으로 설명합니다. Start now. 실무에서는 위 본문의 예제와 선택 가이드를 참고해 적용하면 됩니다.

Q. 선행으로 읽으면 좋은 글은?

A. 각 글 하단의 이전 글 또는 관련 글 링크를 따라가면 순서대로 배울 수 있습니다. C++ 시리즈 목차에서 전체 흐름을 확인할 수 있습니다.

Q. 더 깊이 공부하려면?

A. cppreference와 해당 라이브러리 공식 문서를 참고하세요. 글 말미의 참고 자료 링크도 활용하면 좋습니다.

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

이 글에서 다루는 키워드 (관련 검색어)

Rust, 컬렉션, Vec, HashMap 등으로 검색하시면 이 글이 도움이 됩니다.