Java 주요 컬렉션 비교표

Java 주요 컬렉션 비교표

List / Set / Map 핵심 컬렉션을 “성능·중복·정렬·쓰레드 안전” 관점에서 한 장으로 정리

List
Set
Map
Thread-safe
빠른 결론 (실무 기본값) 선택 스트레스 끝
✅
일반적인 리스트

ArrayList : 인덱스 접근이 빠르고 대부분의 CRUD에 무난합니다.

get O(1) 중간 삽입/삭제 O(n)
✅
중복 제거(Set)

HashSet : 순서 필요 없고 빠른 검색이 목적이면 기본 선택지입니다.

contains O(1) 정렬 X
✅
키-값(Map)

HashMap : 대부분의 일반적 Key-Value 저장소는 HashMap으로 해결됩니다.

get/put O(1) 키 중복 불가
멀티스레드라면 ConcurrentHashMap을 우선 고려하고, Hashtable은 레거시 호환 정도로만 사용합니다.
🧠 선택 가이드 상황별 추천
  • ✅
    인덱스를 자주 참조해야 함 랜덤 접근 중심 UI/목록/캐시
    ArrayList
  • ✅
    앞/중간에 자주 삽입·삭제 리스트 편집/큐 형태 처리
    LinkedList
  • ✅
    중복 제거 + 빠른 검색 회원/태그/유니크 체크
    HashSet
  • ✅
    삽입 순서 유지 + 중복 제거 입력 순서가 의미 있는 Set
    LinkedHashSet
  • ✅
    정렬된 Set 필요 정렬된 목록/범위 탐색
    TreeSet
  • ✅
    키-값 저장(Map) 일반적인 조회/캐시/매핑
    HashMap
  • ✅
    멀티스레드 환경 동시성 보장 + 성능
    ConcurrentHashMap
  • ⚠️
    레거시 코드 호환이 필요 요즘은 거의 안 씀
    Hashtable Legacy
✅ Java 주요 컬렉션 비교표 특징 · 성능 · 중복 · 정렬 · 쓰레드 안전
컬렉션 특징 주요 메서드 성능 중복 허용 정렬 보장 쓰레드 안전
ArrayList 배열 기반 리스트. 인덱스 접근이 빠름 get: O(1) / add/remove: O(n) (중간) 허용 삽입 순서 유지 ❌
LinkedList 이중 연결 리스트. 삽입/삭제가 유리하지만 랜덤 접근이 느림 get: O(n) / add/remove: O(1) (앞/뒤) 허용 삽입 순서 유지 ❌
HashSet 해시 기반 Set. 순서 없음. 검색 빠름 add/remove/contains: O(1) ❌ 중복 불가 ❌ ❌
LinkedHashSet HashSet + 삽입 순서 유지 add/remove/contains: O(1) ❌ ✔ 삽입 순서 유지 ❌
TreeSet Red-Black Tree 기반. 자동 정렬 add/remove/contains: O(log n) ❌ ✔ 정렬됨 자연순/Comparator ❌
HashMap 키-값 저장. 빠른 검색 get/put/remove: O(1) ❌ (키 중복 불가) ❌ ❌
Hashtable Legacy HashMap과 유사. 전체 동기화 기반 Thread-safe get/put: O(1) ❌ ❌ ✔ 느림
ConcurrentHashMap 동시성 보장. 락 분할/비블로킹 최적화(구현 전략은 JVM 버전별 상이) get/put: 평균 O(1) ❌ ❌ ✔ 고성능

⚡ 성능 감각 빠르게 잡기

헷갈리는 포인트만 딱 정리

  • ArrayList는 끝에 add는 빠르지만, 중간 insert는 전체 shift 때문에 느릴 수 있습니다.
  • LinkedList는 임의 접근(get)이 느립니다. “앞/뒤 삽입·삭제”가 핵심일 때만 유리합니다.
  • TreeSet은 정렬을 유지하니 O(log n)으로 느릴 수 있지만, 정렬된 결과가 바로 필요하면 전체 sort 비용을 줄일 수 있습니다.

🧵 쓰레드 안전 선택법

멀티스레드에서는 “락 전략”이 성능을 좌우합니다

  • ConcurrentHashMap : 실무 기본값 (동시성 + 성능)
  • Collections.synchronizedMap(...) : 간단하지만 전체 락 방식이라 경쟁이 심하면 느릴 수 있음
  • Hashtable : 레거시 호환 외에는 거의 사용하지 않음
Tip: “정렬 + 동시성”이 동시에 필요하면 요구사항부터 재검토하거나 별도 구조(스냅샷/복제/락 설계)를 고려하세요.
요약: List는 ArrayList, Set은 HashSet/LinkedHashSet/TreeSet, Map은 HashMap + 멀티스레드는 ConcurrentHashMap.
저작자표시 비영리 변경금지 (새창열림)

'IT > Programming' 카테고리의 다른 글

Java 큐/스택 계열 컬렉션 비교  (0) 2026.01.21
Java 큐/스택 계열 컬렉션 비교

Java 큐/스택 계열 컬렉션 비교

Queue/Deque/Stack/우선순위/동시성/블로킹까지 — “언제 무엇을 쓰는가” 중심으로 정리

스택(LIFO)
큐(FIFO)
우선순위
동시성
블로킹
빠른 결론 (실무 추천) 90%는 여기서 끝
✅
스택은 ArrayDeque로

Stack은 Legacy + 동기화 비용이 있어 대부분 비추천. 스택/큐 모두 ArrayDeque가 빠릅니다.

추천 push/pop O(1) GC/성능 유리 최신 표준
✅
일반 FIFO 큐도 ArrayDeque 우선

LinkedList도 가능하지만, 노드 기반이라 오버헤드가 있어 대체로 ArrayDeque가 더 낫습니다.

추천 offer/poll/peek O(1) 캐시 친화적
키워드: 단일 스레드(빠름) → ArrayDeque / 우선순위 → PriorityQueue / 멀티스레드 → ConcurrentLinkedQueue 또는 BlockingQueue
선택 체크리스트 텍스트 정렬 개선
  • ✅
    FIFO만 필요? 일반 작업 대기열 / 이벤트 처리
    ArrayDeque
  • ✅
    LIFO가 필요? 스택(괄호 검사, DFS 등)
    ArrayDeque push/pop
  • ✅
    앞/뒤 모두 넣고 빼야 함? 슬라이딩 윈도우 / 양방향 처리
    Deque + ArrayDeque
  • ✅
    우선순위가 핵심? 가장 작은/큰 값 반복 추출
    PriorityQueue
  • ✅
    멀티스레드에서 비블로킹? 락 없이 빠르게 흘려보내기
    ConcurrentLinkedQueue
  • ✅
    생산자-소비자(대기/알림) 필요? 백프레셔 / put-take 패턴
    BlockingQueue
주의: PriorityQueue는 전체 정렬이 아니라 “루트만 최소/최대”를 보장하는 힙 구조입니다.
✅ 큐/스택 계열 컬렉션 비교표 특징 · 주요 메서드 · 복잡도 · 사용 시점
컬렉션 특징 주요 메서드 시간 복잡도(대표) 용도 / 사용 시점
Stack Legacy 후입선출(LIFO). Vector 기반(동기화)이라 비용이 큼 push(), pop(), peek() O(1) 비추천 (대체: ArrayDeque)
Queue 인터페이스 선입선출(FIFO) 추상화 offer(), poll(), peek() O(1) 일반적인 작업 대기열, 이벤트 처리
LinkedList Queue + Deque 구현. 양 끝 삽입/삭제는 빠르나 노드 오버헤드 존재 add(), remove(), get() 양끝 삽입/삭제 O(1) / 임의 접근 O(n) Deque가 필요하고 요소가 적을 때 유연. 보통은 ArrayDeque가 더 빠름
ArrayDeque 추천 배열 기반 Deque 구현체. 스택/큐 대체로 매우 우수 addFirst(), addLast(), pollFirst(), push(), pop() O(1) 스택(LIFO), 큐(FIFO), 양방향 처리까지 “기본 선택지”
PriorityQueue 우선순위 큐(힙). 정렬이 아니라 우선순위 pop에 최적 offer(), poll(), peek() 삽입/삭제 O(log n), peek O(1) 스케줄링, Dijkstra/A* 등 “가장 작은/큰 값 반복 추출”
ConcurrentLinkedQueue 멀티스레드용 비블로킹 큐 (lock-free 계열) offer(), poll() 평균 O(1) 고성능 멀티스레드 이벤트 처리(대기 없이 흘려보내기)
BlockingQueue 인터페이스 스레드 간 전달에 특화. 대기(블로킹) 기반 put(), take() 대표 구현체에 따라 다름 (보통 O(1)) 생산자-소비자 패턴, 백프레셔(backpressure) 필요할 때
Deque 인터페이스 양방향 큐(앞/뒤 삽입·삭제 모두 지원) addFirst(), addLast(), pollFirst(), pollLast() O(1) 슬라이딩 윈도우, 캐시, 양방향 작업(undo/redo 등)
PriorityBlockingQueue 우선순위 + 블로킹 큐. 내부적으로 힙 사용 put(), take() O(log n) 멀티스레드에서 우선순위 기반 처리(작업 스케줄러 등)
📌 주요 예제 코드 바로 복붙해서 쓰기
스택 (LIFO) — Deque + ArrayDeque
// Stack (LIFO)
Deque<String> stack = new ArrayDeque<>();
stack.push("A");
stack.push("B");
System.out.println(stack.pop());  // B
System.out.println(stack.peek()); // A
큐 (FIFO) — Queue
// Queue (FIFO)
Queue<String> queue = new ArrayDeque<>();
queue.offer("A");
queue.offer("B");
System.out.println(queue.poll()); // A
System.out.println(queue.peek()); // B
우선순위 큐 — min-heap 기본
// PriorityQueue (min-heap)
PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(3);
pq.offer(1);
pq.offer(2);
System.out.println(pq.poll()); // 1
System.out.println(pq.poll()); // 2
Deque — 앞/뒤 자유
// Deque
Deque<String> deque = new ArrayDeque<>();
deque.addFirst("front");
deque.addLast("back");
System.out.println(deque.pollFirst()); // front
System.out.println(deque.pollLast());  // back
💡
예외/반환 차이도 같이 기억하면 실무에서 편합니다

add/remove는 실패 시 예외를 던질 수 있고, offer/poll은 실패 시 false/null로 반환하는 스타일입니다.

요약: 단일 스레드 기본값은 ArrayDeque, 우선순위는 PriorityQueue, 멀티스레드는 Concurrent/Blocking 계열로 분기.
저작자표시 비영리 변경금지 (새창열림)

'IT > Programming' 카테고리의 다른 글

Java 주요 컬렉션 비교표  (0) 2026.01.21

+ Recent posts

티스토리툴바