1. List — 순서 있고, 중복 허용
순차 저장, 인덱스 접근, 중복 데이터 가능
① ArrayList
- 활용: 조회 빈번, 중간 삽입/삭제 적은 경우
- 주요 메서드
List<String> list = new ArrayList<>();
list.add("A"); // 끝에 추가
list.add(1, "B"); // 인덱스 위치에 추가
list.get(0); // 인덱스로 조회
list.set(0, "C"); // 값 변경
list.remove(1); // 인덱스 삭제
list.contains("A"); // 값 포함 여부
list.size(); // 크기 조회
list.clear(); // 전체 삭제
② LinkedList
- 활용: 삽입/삭제 잦은 경우, Queue/Deque로도 사용 가능
- 추가 메서드 (Deque 지원)
LinkedList<String> ll = new LinkedList<>();
ll.addFirst("A"); // 앞에 추가
ll.addLast("B"); // 뒤에 추가
ll.removeFirst(); // 앞 요소 제거
ll.removeLast(); // 뒤 요소 제거
③ Stack
- 활용: LIFO 구조 (뒤에서 꺼내기)
Stack<Integer> stack = new Stack<>();
stack.push(1); // 삽입
stack.push(2);
stack.pop(); // 꺼내기
stack.peek(); // 맨 위 조회
stack.isEmpty(); // 비었는지 확인
2. Set — 순서 없음(일부 예외), 중복 불허
중복 제거, 빠른 검색
① HashSet
- 활용: 순서 불필요, 빠른 중복 제거
Set<String> set = new HashSet<>();
set.add("A"); // 추가
set.add("B");
set.add("A"); // 무시됨 (중복 불허)
set.contains("B"); // 포함 여부
set.remove("A"); // 삭제
set.size(); // 크기
set.clear(); // 전체 삭제
② LinkedHashSet
- 활용: 입력 순서 유지 + 중복 제거
Set<Integer> lhs = new LinkedHashSet<>();
lhs.add(3); lhs.add(1); lhs.add(2);
System.out.println(lhs); // [3, 1, 2]
③ TreeSet
- 활용: 자동 정렬된 집합
Set<Integer> ts = new TreeSet<>();
ts.add(3); ts.add(1); ts.add(2);
System.out.println(ts); // [1, 2, 3]
((TreeSet<Integer>) ts).first(); // 최소값
((TreeSet<Integer>) ts).last(); // 최대값
3. Queue / Deque — FIFO 또는 양방향
대기열, BFS, 작업 스케줄링
① Queue (LinkedList)
Queue<String> q = new LinkedList<>();
q.offer("A"); // 삽입
q.offer("B");
q.poll(); // 꺼내기
q.peek(); // 맨 앞 조회
q.isEmpty(); // 비었는지 확인
② PriorityQueue
Queue<Integer> pq = new PriorityQueue<>(); // 최소힙
pq.offer(3);
pq.offer(1);
pq.offer(2);
pq.poll(); // 1 (가장 작은 값 꺼냄)
Queue<Integer> maxPq = new PriorityQueue<>(Comparator.reverseOrder()); // 최대힙
③ ArrayDeque
Deque<String> dq = new ArrayDeque<>();
dq.offerFirst("A"); // 앞 삽입
dq.offerLast("B"); // 뒤 삽입
dq.pollFirst(); // 앞 꺼내기
dq.pollLast(); // 뒤 꺼내기
4. Map — 키-값 쌍 저장
키 중복 불허, 값 중복 가능, 빠른 조회
① HashMap
Map<String, Integer> map = new HashMap<>();
map.put("A", 1); // 추가
map.put("B", 2);
map.get("A"); // 값 조회
map.containsKey("A"); // 키 존재 여부
map.containsValue(1); // 값 존재 여부
map.remove("B"); // 삭제
map.keySet(); // 모든 키
map.values(); // 모든 값
map.entrySet(); // 키-값 쌍
② LinkedHashMap
Map<Integer, String> lhm = new LinkedHashMap<>();
lhm.put(1, "A");
lhm.put(2, "B");
System.out.println(lhm); // 입력 순서 유지
③ TreeMap
Map<Integer, String> tm = new TreeMap<>();
tm.put(3, "C");
tm.put(1, "A");
tm.put(2, "B");
System.out.println(tm); // 키 자동 정렬
🔹 정리
| 목적 | 추천 구현체 | 핵심 메서드 |
| 순서 + 중복 허용 | ArrayList | add(), get(), set(), remove() |
| 삽입/삭제 잦음 | LinkedList | addFirst(), addLast(), removeFirst() |
| LIFO 스택 | Stack | push(), pop(), peek() |
| 중복 제거, 빠른 검색 | HashSet | add(), contains(), remove() |
| 순서 유지 + 중복 제거 | LinkedHashSet | add(), iterator() |
| 정렬된 집합 | TreeSet | add(), first(), last() |
| 일반 큐 | LinkedList | offer(), poll(), peek() |
| 우선순위 큐 | PriorityQueue | offer(), poll(), peek() |
| 양방향 큐 | ArrayDeque | offerFirst(), offerLast(), pollFirst(), pollLast() |
| Key-Value 저장 | HashMap | put(), get(), remove(), containsKey() |
| 순서 유지 Map | LinkedHashMap | put(), get(), entrySet() |
| 정렬 Map | TreeMap | put(), firstKey(), lastKey() |