Rust 컬렉션 | Vec, HashMap, HashSet

시리즈 안내

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

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

일상 비유로 이해하기: 메모리를 아파트 건물로 생각해보세요. 스택은 엘리베이터 같아서 빠르지만 공간이 제한적입니다. 힙은 창고처럼 넓지만 물건을 찾는 데 시간이 걸립니다. 포인터는 “3층 302호”처럼 주소를 가리키는 메모지라고 보면 됩니다.

정리

핵심 요약

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은 실측 후 사용

다음 단계

• 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]

심화 부록: 구현·운영 관점

이 부록은 앞선 본문에서 다룬 주제(「Rust 컬렉션 | Vec, HashMap, HashSet」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.

내부 동작과 핵심 메커니즘

flowchart TD
  A[입력·요청·이벤트] --> B[파싱·검증·디코딩]
  B --> C[핵심 연산·상태 전이]
  C --> D[부작용: I/O·네트워크·동시성]
  D --> E[결과·관측·저장]

sequenceDiagram
  participant C as 클라이언트/호출자
  participant B as 경계(런타임·게이트웨이·프로세스)
  participant D as 의존성(API·DB·큐·파일)
  C->>B: 요청/이벤트
  B->>D: 조회·쓰기·RPC
  D-->>B: 지연·부분 실패·재시도 가능
  B-->>C: 응답 또는 오류(코드·상관 ID)

• 불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
• 결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
• 경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
• 백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.

프로덕션 운영 패턴

영역	운영 관점 질문
관측성	요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가
안전성	입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가
신뢰성	재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가
성능	캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가
배포	롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가
용량	피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가

스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.

확장 예시: 엔드투엔드 미니 시나리오

앞선 본문 주제(「Rust 컬렉션 | Vec, HashMap, HashSet」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

1. 입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
2. 핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
3. 실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
4. 호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
5. 부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.

handle(request):
  ctx = newCorrelationId()
  validated = validateSchema(request)
  authorize(validated, ctx)
  result = domainCore(validated)
  persistOrEmit(result, idempotentKey)
  recordMetrics(ctx, latency, outcome)
  return result

문제 해결(Troubleshooting)

증상	가능 원인	조치
간헐적 실패	레이스, 타임아웃, 외부 의존성, DNS	최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검
성능 저하	N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스	프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거
메모리 증가	캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납	상한·TTL·힙/FD 스냅샷 비교
빌드·배포만 실패	환경 변수, 권한, 플랫폼 차이, lockfile	CI 로그와 로컬 diff, 런타임·이미지 버전 핀
설정 불일치	프로필·시크릿·기본값, 리전	스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화
데이터 불일치	비멱등 재시도, 부분 쓰기, 캐시 무효화 누락	멱등 키·아웃박스·트랜잭션 경계 재검토

권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.

배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.

---

자주 묻는 질문 (FAQ)

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

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

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

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

Q. 더 깊이 공부하려면?

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

---

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

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

• Rust 트레이트 | Trait, 제네릭, 트레이트 바운드
• Rust 동시성 | Thread, Channel, Arc, Mutex
• Rust 소유권 | Ownership, Borrowing, Lifetime

---

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

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