Vec은 언제 사용하나요?

크기가 변하는 배열이 필요할 때 사용합니다. C++의 vector와 비슷합니다.

HashMap과 BTreeMap의 차이는?

HashMap은 순서 없음(빠름), BTreeMap은 키로 정렬됨(느림).

iter()와 into_iter()의 차이는?

iter()는 참조 반복, into_iter()는 소유권 이동입니다.

Rust 컬렉션 | Vec, HashMap, HashSet

2026년 3월 29일 · 30분 읽기 · 수정 2026년 3월 30일 중급 튜토리얼

이 글의 핵심

Rust 컬렉션에 대해 정리한 개발 블로그 글입니다. let mut v = vec![1, 2, 3, 4, 5];

들어가며

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` 선택 기준

기준	HashMap	BTreeMap
키 순서	없음(해시 순서)	키 정렬 순으로 순회
평균 조회/삽입	O(1) 수준(해시)	O(log n)
키 타입	`Hash + Eq`	`Ord`
용도 예	캐시, 카운터, 일반 룩업	범위 쿼리, 정렬된 키 나열, “가장 가까운 키”

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은 재할당 비용이 될 수 있으므로, 프로파일로 병목을 확인한 뒤 적용하는 것이 안전합니다.

정리

핵심 요약

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

다음 단계

Rust 동시성
Rust 비동기
Rust 웹 개발

Java 컬렉션 | ArrayList, HashMap, Set
C++와 Rust: 두 언어의 상호 운용성과 Memory Safety 논쟁의 실체 [#44-2]
C++ vs Rust 완전 비교 | 소유권·메모리 안전성·에러 처리·동시성·성능 실전 가이드
Rust 메모리 안전성 완벽 가이드 | 소유권·Borrow checker·수명·unsafe 실전
Rust vs C++ 메모리 안전성 | 컴파일러 오류 차이 [#47-3]

이 글의 핵심

들어가며

1. Vec (동적 배열)

기본 사용

Vec 메서드

Vec 순회

2. HashMap<K, V>

기본 사용

HashMap 메서드

3. HashSet

4. 반복자 (Iterator)

기본 반복자

반복자 메서드

5. 실전 예제

예제: 단어 빈도 카운터

6. Vec vs VecDeque vs LinkedList 성능 관점

7. HashMap vs BTreeMap 선택 기준

8. Entry API 활용 (실전)

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

정리

핵심 요약

다음 단계

관련 글

6. `Vec` vs `VecDeque` vs `LinkedList` 성능 관점

7. `HashMap` vs `BTreeMap` 선택 기준

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