[2026] Rust 컬렉션 | Vec, HashMap, HashSet
![[2026] Rust 컬렉션 | Vec, HashMap, HashSet](/og/s/rust-series-06-collections.webp)
이 글의 핵심
let mut v = vec![1, 2, 3, 4, 5];.
들어가며
Vec·HashMap 등 컬렉션은 요소의 소유권을 어떻게 넣고 빼는지가 API마다 다릅니다. 열쇠를 넘기는지(push), 잠깐 빌려만 보는지(iter)를 구분하면 읽기 쉽습니다.
1. Vec (동적 배열)
기본 사용
다음은 rust를 활용한 상세한 구현 코드입니다. 함수를 통해 로직을 구현합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
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 메서드
다음은 rust를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
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 순회
다음은 rust를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
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>
기본 사용
다음은 rust를 활용한 상세한 구현 코드입니다. 함수를 통해 로직을 구현합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
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 메서드
다음은 rust를 활용한 상세한 구현 코드입니다. 에러 처리를 통해 안정성을 확보합니다, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
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
다음은 rust를 활용한 상세한 구현 코드입니다. 함수를 통해 로직을 구현합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
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)
기본 반복자
다음은 rust를 활용한 상세한 구현 코드입니다. 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
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();반복자 메서드
다음은 rust를 활용한 상세한 구현 코드입니다. 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
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. 실전 예제
예제: 단어 빈도 카운터
다음은 rust를 활용한 상세한 구현 코드입니다. 함수를 통해 로직을 구현합니다, 에러 처리를 통해 안정성을 확보합니다, 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
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를 검토하세요. | ||||
| 아래 코드는 rust를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요. |
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(..)로 부분 구간 순회하거나, 디버깅 시 결정적인 순서가 필요할 때 유리합니다. | ||
| 아래 코드는 rust를 사용한 구현 예제입니다. 반복문으로 데이터를 처리합니다. 코드를 직접 실행해보면서 동작을 확인해보세요. |
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가 대표적입니다.
다음은 rust를 활용한 상세한 구현 코드입니다. 에러 처리를 통해 안정성을 확보합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
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()vscapacity():len은 요소 개수,capacity는 예약된 슬롯입니다.capacity - len이 곧 여유 공간입니다.- shrink_to_fit: 사용량이 줄어든 뒤 메모리를 OS에 반환하고 싶을 때 호출합니다. 매 호출마다 쓰기보다, 큰 맵/벡터를 비운 직후 등 구간에 쓰는 편이 낫습니다.
- HashMap::shrink_to_fit: 해시 테이블도 마찬가지로, 요소가 많이 빠진 뒤에 고려합니다. 아래 코드는 rust를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.
// 변수 선언 및 초기화
let mut v = Vec::with_capacity(1000);
for i in 0..10 {
v.push(i);
}
v.shrink_to_fit(); // 실제 사용(10개)에 맞게 줄이기 시도과도한 shrink_to_fit은 재할당 비용이 될 수 있으므로, 프로파일로 병목을 확인한 뒤 적용하는 것이 안전합니다.
일상 비유로 이해하기: 메모리를 아파트 건물로 생각해보세요. 스택은 엘리베이터 같아서 빠르지만 공간이 제한적입니다. 힙은 창고처럼 넓지만 물건을 찾는 데 시간이 걸립니다. 포인터는 “3층 302호”처럼 주소를 가리키는 메모지라고 보면 됩니다.
정리
핵심 요약
- 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은 실측 후 사용