[Java] Collection Framework

허경두·2025년 4월 3일

Collections Framework Java KDT 내일배움카드 패스트캠퍼스

Java

목록 보기

9/12

컬렉션 프레임워크

컬렉션 프레임워크(Collections Framework) : 데이터 군을 저장하는 클래스들을 표준화한 설계

컬렉션 프레임워크의 핵심 인터페이스와 구현체

Collection (인터페이스)
- List (인터페이스)
  - ArrayList
  - LinkedList
  - Vector
    - Stack
- Set (인터페이스)
  - HashSet
    - LinkedHashSet
  - TreeSet (SortedSet 인터페이스 구현)
- Queue (인터페이스)
  - LinkedList (Queue & Deque 구현)
  - PriorityQueue
  - ArrayDeque (Deque 인터페이스 구현)
- Deque (인터페이스)
  - LinkedList
  - ArrayDeque
Map (인터페이스)
- HashMap
  - LinkedHashMap
- TreeMap (SortedMap 인터페이스 구현)
- Hashtable
  - Properties

컬렉션 프레임워크의 메서드

메서드	설명
`boolean add(E e)`	요소 추가
`boolean remove(Object o)`	특정 요소 삭제
`boolean contains(Object o)`	요소 포함 여부 확인
`int size()`	요소 개수 반환
`boolean isEmpty()`	컬렉션이 비어 있는지 확인
`void clear()`	모든 요소 제거
`Iterator<E> iterator()`	컬렉션의 요소를 순회할 반복자 반환
`boolean addAll(Collection<? extends E> c)`	다른 컬렉션의 모든 요소 추가
`boolean removeAll(Collection<?> c)`	특정 컬렉션에 포함된 모든 요소 삭제
`boolean retainAll(Collection<?> c)`	특정 컬렉션에 포함된 요소만 유지하고 나머지 삭제
`Object[] toArray()`	컬렉션을 배열로 변환
`<T> T[] toArray(T[] a)`	지정한 타입의 배열로 변환

List

List : 중복을 허용하면서 저장 순서가 유지되는 컬렉션

List 인터페이스의 주요 메서드

메서드	설명
`void add(int index, E element)`	특정 위치에 요소 추가
`boolean add(E e)`	리스트의 끝에 요소 추가
`E get(int index)`	특정 위치의 요소 반환
`E set(int index, E element)`	특정 위치의 요소 변경
`E remove(int index)`	특정 위치의 요소 삭제
`boolean remove(Object o)`	특정 요소 삭제
`int indexOf(Object o)`	특정 요소의 첫 번째 인덱스 반환 (없으면 `-1`)
`int lastIndexOf(Object o)`	특정 요소의 마지막 인덱스 반환
`boolean contains(Object o)`	리스트에 특정 요소가 포함되어 있는지 확인
`int size()`	리스트의 요소 개수 반환
`boolean isEmpty()`	리스트가 비어 있는지 확인
`void clear()`	모든 요소 제거
`List<E> subList(int fromIndex, int toIndex)`	특정 범위의 요소를 포함하는 서브 리스트 반환
`Iterator<E> iterator()`	리스트를 순회할 반복자 반환
`ListIterator<E> listIterator()`	리스트를 양방향으로 순회할 반복자 반환
`void sort(Comparator<? super E> c)`	리스트 정렬

ArrayList

ArrayList 는 동적 배열을 기반으로 한 List 구현체로, 빠른 요소 접근과 자동 크기 조정 기능, 요소의 추가, 삭제, 검색 기능을 제공

public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable {
	...
	transient Object[] elementData;
    ...
}

배열의 장점과 단점

장점
1. 자료구조가 간단하며 사용하기 쉽다
2. 데이터 접근시간이 가장 빠르다
단점
1. 크기를 변경할 수 없다
2. 비순차적인 데이터의 추가 또는 삭제에 시간이 많이 걸린다
  * 비순차적인 데이터 : 배열 중간에 있는 데이터
배열의 인덱스 접근 수식
인덱스가 n인 데이터의 주소 = 배열의 주소 + n * 데이터 타입의 크기

ArrayList의 생성자

생성자	설명
`ArrayList()`	초기 용량이 `10`인 빈 리스트 생성
`ArrayList(int initialCapacity)`	지정된 용량으로 리스트 생성
`ArrayList(Collection<? extends E> c)`	주어진 컬렉션의 요소를 포함하는 리스트 생성

ArrayList의 메서드

1️⃣ 요소 추가 (Add)

메서드	설명
`boolean add(E e)`	리스트 끝에 요소 추가
`void add(int index, E element)`	특정 위치에 요소 삽입
`boolean addAll(Collection<? extends E> c)`	주어진 컬렉션의 모든 요소 추가
`boolean addAll(int index, Collection<? extends E> c)`	특정 위치에 컬렉션의 모든 요소 추가

2️⃣ 요소 검색 (Access)

메서드	설명
`E get(int index)`	특정 위치의 요소 반환
`boolean contains(Object o)`	특정 요소 포함 여부 확인
`int indexOf(Object o)`	특정 요소의 첫 번째 인덱스 반환 (없으면 `-1`)
`int lastIndexOf(Object o)`	특정 요소의 마지막 인덱스 반환

3️⃣ 요소 삭제 (Remove)

메서드	설명
`E remove(int index)`	특정 위치의 요소 삭제 및 반환
`boolean remove(Object o)`	리스트에서 특정 요소 삭제
`boolean removeAll(Collection<?> c)`	특정 컬렉션의 모든 요소 삭제
`boolean retainAll(Collection<?> c)`	특정 컬렉션에 포함된 요소만 유지하고 나머지 삭제
`void clear()`	모든 요소 제거

4️⃣ 요소 변경 (Update)

메서드	설명
`E set(int index, E element)`	특정 위치의 요소 변경
`void replaceAll(UnaryOperator<E> operator)`	모든 요소를 지정된 연산자로 변환

5️⃣ 기타 메서드

메서드	설명
`void ensureCapacity(int minCapacity)`	내부 배열의 크기를 특정 용량 이상으로 확장
`void trimToSize()`	리스트의 용량을 현재 크기로 조정하여 메모리 절약
`void replaceAll(UnaryOperator<E> operator)`	모든 요소를 지정된 연산자로 변환
`void sort(Comparator<? super E> c)`	리스트 정렬
`Spliterator<E> spliterator()`	리스트를 분할하여 병렬 처리를 위한 `Spliterator` 반환
`boolean removeIf(Predicate<? super E> filter)`	조건을 만족하는 요소들을 삭제
`void forEach(Consumer<? super E> action)`	모든 요소에 대해 특정 동작 수행

위와 같이 메서드가 많기 때문에 많은 메모리 공간을 차지한다
자동으로 크기가 조절되지만 처리시간이 많이 소요되기 때문에 실제 저장할 개수보다 약간 여유있게 크기를 지정하는 것이 좋다

remove()의 동작 과정

삭제할 데이터의 아래에 있는 데이터를 한 칸씩 위로 복사해서 삭제할 데이터를 덮어쓴다
마지막 데이터를 null로 변경한다
size를 1 감소시킨다

LinkedList

LinkedList는 이중 연결 리스트를 기반으로 구현된 List
Deque, Queue인터페이스를 지원하는 자료구조

배열의 단점을 보완하기 위해 고안되었다
출처
단방향인 링크드 리스트는 이전 요소에 대한 접근이 어렵기 때문에 더블 링크드 리스트가 고안되었다
출처
더블 링크드 리스트의 접근성을 보다 향상시킨 써큘러 더블 링크드 리스트
마지막 요소의 다음을 첫 요소로, 첫 요소의 이전을 마지막 요소로 연결했다
출처
실제 LinkedList는 더블 링크드 리스트로 구현되어 있다 (써큘러 더블 링크드 리스트 아님)

LinkedList의 생성자

생성자	설명
`LinkedList()`	빈 연결 리스트 생성
`LinkedList(Collection<? extends E> c)`	주어진 컬렉션의 요소를 포함하는 연결 리스트 생성

LinkedList의 메서드

1️⃣ 요소 추가 (Add)

메서드	설명
`boolean add(E e)`	리스트 끝에 요소 추가
`void add(int index, E element)`	특정 위치에 요소 삽입
`boolean addAll(Collection<? extends E> c)`	주어진 컬렉션의 모든 요소 추가
`boolean addAll(int index, Collection<? extends E> c)`	특정 위치에 컬렉션의 모든 요소 추가
`void addFirst(E e)`	리스트의 맨 앞에 요소 추가
`void addLast(E e)`	리스트의 맨 뒤에 요소 추가

2️⃣ 요소 검색 (Access)

메서드	설명
`E get(int index)`	특정 위치의 요소 반환
`E getFirst()`	첫 번째 요소 반환
`E getLast()`	마지막 요소 반환
`boolean contains(Object o)`	특정 요소 포함 여부 확인

3️⃣ 요소 삭제 (Remove)

메서드	설명
`E remove(int index)`	특정 위치의 요소 삭제 및 반환
`boolean remove(Object o)`	리스트에서 특정 요소 삭제
`E removeFirst()`	첫 번째 요소 삭제 및 반환
`E removeLast()`	마지막 요소 삭제 및 반환
`boolean removeAll(Collection<?> c)`	특정 컬렉션의 모든 요소 삭제
`boolean retainAll(Collection<?> c)`	특정 컬렉션에 포함된 요소만 유지하고 나머지 삭제
`void clear()`	모든 요소 제거

4️⃣ 요소 변경 (Update)

메서드	설명
`E set(int index, E element)`	특정 위치의 요소 변경

5️⃣ 기타 메서드

메서드	설명
`void addFirst(E e)`	리스트의 맨 앞에 요소 추가
`void addLast(E e)`	리스트의 맨 뒤에 요소 추가
`E getFirst()`	첫 번째 요소 반환 (없으면 `NoSuchElementException`)
`E getLast()`	마지막 요소 반환 (없으면 `NoSuchElementException`)
`E removeFirst()`	첫 번째 요소 제거 후 반환 (없으면 `NoSuchElementException`)
`E removeLast()`	마지막 요소 제거 후 반환 (없으면 `NoSuchElementException`)
`E peekFirst()`	첫 번째 요소 반환 (없으면 `null`)
`E peekLast()`	마지막 요소 반환 (없으면 `null`)
`E pollFirst()`	첫 번째 요소 제거 후 반환 (없으면 `null`)
`E pollLast()`	마지막 요소 제거 후 반환 (없으면 `null`)
`void push(E e)`	스택처럼 리스트 앞에 요소 추가 (`addFirst(e)` 와 동일)
`E pop()`	스택처럼 리스트 앞에서 요소 제거 후 반환 (`removeFirst()` 와 동일)
`boolean offerFirst(E e)`	첫 번째 요소 추가 (성공 여부 반환)
`boolean offerLast(E e)`	마지막 요소 추가 (성공 여부 반환)
`boolean removeFirstOccurrence(Object o)`	리스트에서 첫 번째로 발견된 특정 요소 제거
`boolean removeLastOccurrence(Object o)`	리스트에서 마지막으로 발견된 특정 요소 제거
`DescendingIterator<E> descendingIterator()`	리스트를 역순으로 순회할 반복자 반환

ArrayList vs. LinkedList

비교 항목	ArrayList	LinkedList
구조	동적 배열 기반	이중 연결 리스트(Doubly Linked List) 기반
메모리 사용	요소만 저장 (추가적인 포인터 없음)	각 노드가 이전/다음 노드에 대한 참조(`prev`, `next`)를 저장하여 추가 메모리 사용
삽입/삭제 성능	중간 삽입/삭제 시 `O(n)` (요소를 이동해야 함)	중간 삽입/삭제 시 `O(1)` (참조 변경만 수행)
검색 성능	`O(1)` (배열 인덱스로 즉시 접근 가능)	`O(n)` (처음부터 순차 탐색 필요)
첫 번째/마지막 요소 접근	`O(1)` (인덱스로 바로 접근 가능)	`O(1)` (first, last 포인터 저장)
중간 요소 접근	`O(1)` (인덱스로 즉시 접근)	`O(n)` (앞/뒤로 탐색해야 함)
반복자(iterator) 성능	빠름 (`ArrayList`는 `RandomAccess` 인터페이스 구현)	느릴 수 있음 (노드를 순차적으로 탐색)
메모리 사용량	상대적으로 적음 (배열만 저장)	상대적으로 많음 (각 노드가 추가적인 참조 필드 포함)
정렬 성능	`O(n log n)` (빠름)	`O(n log n)` (노드의 참조를 변경해야 하므로 상대적으로 느림)
멀티스레드 환경	동기화가 필요함 (`Collections.synchronizedList()` 사용 가능)	동기화가 필요함 (`Collections.synchronizedList()` 사용 가능)
적합한 용도	검색이 빈번한 경우	삽입/삭제가 빈번한 경우

Stack

LIFO(Last In First Out)

Stack의 메서드

1️⃣ 요소 추가 (Push)

메서드	설명
`E push(E item)`	스택의 맨 위에 요소 추가

2️⃣ 요소 제거 및 조회 (Pop & Peek)

메서드	설명
`E pop()`	스택의 맨 위 요소를 제거하고 반환 (비었을 경우 `EmptyStackException` 발생)
`E peek()`	스택의 맨 위 요소를 제거하지 않고 반환 (비었을 경우 `EmptyStackException` 발생)

3️⃣ 요소 검색 (Search)

메서드	설명
`int search(Object o)`	특정 요소의 위치 반환 (위에서부터 1부터 시작, 없으면 `-1`)

4️⃣ 기타 메서드 (기본 컬렉션 메서드 포함)

메서드	설명
`boolean empty()`	스택이 비어있는지 확인 (`true` 반환 시 비어 있음)

Queue

FIFO(First In First Out)

Queue의 메서드

1️⃣ 요소 추가 (삽입)

메서드	설명
`boolean add(E e)`	큐의 맨 뒤에 요소 추가 (성공 시 `true`, 공간이 없으면 `IllegalStateException` 발생)
`boolean offer(E e)`	큐의 맨 뒤에 요소 추가 (성공하면 `true`, 실패하면 `false` 반환)

2️⃣ 요소 제거 (삭제)

메서드	설명
`E remove()`	큐의 맨 앞 요소를 제거하고 반환 (비었으면 `NoSuchElementException` 발생)
`E poll()`	큐의 맨 앞 요소를 제거하고 반환 (비었으면 `null` 반환)

3️⃣ 요소 조회 (확인)

메서드	설명
`E element()`	큐의 맨 앞 요소를 조회 (비었으면 `NoSuchElementException` 발생)
`E peek()`	큐의 맨 앞 요소를 조회 (비었으면 `null` 반환)

PriorityQueue

저장한 순서에 관계없이 우선순위가 높은 것부터 꺼내는 큐

특징

자동 정렬
- 요소가 추가될 때 자연 순서(Natural Order) 또는 지정된 비교기(Comparator)에 따라 정렬됨.
- 예를 들어, 숫자는 오름차순(기본 정렬) 으로 저장되며, 문자열은 알파벳순 으로 정렬됨.
- 최소 힙(Min-Heap) 구조 를 사용하여 가장 낮은 값이 먼저 삭제됨.
- Comparator 를 사용하면 사용자 정의 정렬 방식 지정 가능.
FIFO(선입선출) 아님 → 우선순위 기반 처리
- Queue 인터페이스를 구현했지만 선입선출(FIFO)이 아니라 우선순위가 높은 요소가 먼저 처리됨.
Null 요소 저장 불가능
- null 을 추가하려고 하면 NullPointerException 발생.
중복된 값 허용
- 동일한 값을 여러 번 추가 가능.
내부적으로 힙(Heap) 자료구조 사용
- PriorityQueue 는 힙(Heap) 기반의 완전 이진 트리 를 사용하여 정렬.
- 요소 추가(offer())와 삭제(poll()) 연산이 O(log n) 의 시간 복잡도를 가짐.

Deque(Double-Ended Queue)

양쪽 끝에 추가/삭제가 가능한 큐

Deque의 구현체

ArrayDeque (java.util.ArrayDeque)
배열 기반으로 구현된 비순환(circular) 덱
- ArrayList 와 유사하지만, 크기가 자동으로 증가하며 동적 배열을 사용
- LinkedList 보다 빠른 성능(O(1) 삽입/삭제) 을 제공
- null 요소 추가 불가
- 스택과 큐 역할을 모두 수행 가능
LinkedList (java.util.LinkedList)
- 이중 연결 리스트(Doubly Linked List) 기반으로 구현된 덱
- ArrayDeque 보다 메모리 사용량이 크지만, 중간 삽입/삭제가 용이
- null 요소 추가 가능
- 모든 Deque 연산을 O(1)으로 처리 가능, 다만 캐시 효율이 낮음
ConcurrentLinkedDeque (java.util.concurrent.ConcurrentLinkedDeque)
- 비블로킹(Non-blocking) 스레드 안전한 덱
- 내부적으로 CAS(Compare-And-Swap) 알고리즘을 사용하여 동시성 제어
- 고성능 멀티스레드 환경에 적합
- LinkedList 기반이지만, 락(Lock)을 사용하지 않으므로 높은 성능 제공
LinkedBlockingDeque (java.util.concurrent.LinkedBlockingDeque)
스레드 안전한(Blocking) 덱
- 생산자-소비자 패턴(Producer-Consumer Pattern)에서 유용
- 최대 크기를 설정할 수 있어, 큐 크기 제한 가능
- 내부적으로 두 개의 락(Lock)을 사용하여 동기화 처리
- 성능이 중요하지만 메모리 제한이 필요한 환경에서 사용

Set

Set : 중복을 허용하지 않고 저장 순서가 유지되지 않는 컬렉션

Set 인터페이스의 주요 메서드

메서드	설명
`boolean add(E e)`	요소 추가 (중복된 값이면 추가되지 않음)
`boolean remove(Object o)`	특정 요소 삭제
`boolean contains(Object o)`	특정 요소가 포함되어 있는지 확인
`int size()`	요소 개수 반환
`boolean isEmpty()`	Set이 비어 있는지 확인
`void clear()`	모든 요소 제거
`Iterator<E> iterator()`	Set의 요소를 순회할 반복자 반환
`boolean addAll(Collection<? extends E> c)`	다른 컬렉션의 모든 요소 추가 (중복된 값은 무시됨)
`boolean removeAll(Collection<?> c)`	특정 컬렉션에 포함된 모든 요소 삭제
`boolean retainAll(Collection<?> c)`	특정 컬렉션에 포함된 요소만 유지하고 나머지 삭제
`Object[] toArray()`	Set을 배열로 변환
`<T> T[] toArray(T[] a)`	지정한 타입의 배열로 변환

HashSet

Set 인터페이스를 구현한 순서가 없는 컬렉션

특징

중복을 허용하지 않음 (같은 요소 여러 개 저장 불가)
내부적으로 HashMap을 사용하여 저장
null 값 저장 가능 (단, 하나만 허용)
해시 기반 자료구조로 빠른 검색, 추가, 삭제 가능 (O(1))
동기화되지 않음 → 멀티스레드 환경에서는 Collections.synchronizedSet() 사용 필요

HashSet의 생성자

생성자	설명
`HashSet()`	기본 초기 용량 16, 기본 로드 팩터 0.75
`HashSet(int initialCapacity)`	초기 용량을 지정하여 `HashSet` 생성
`HashSet(int initialCapacity, float loadFactor)`	초기 용량과 로드 팩터를 지정
`HashSet(Collection<? extends E> c)`	주어진 컬렉션의 요소를 포함하는 `HashSet` 생성

HashSet의 주요 메서드

메서드	설명	반환 타입
`boolean add(E e)`	요소를 추가 (`중복된 값은 추가되지 않음`)	`boolean`
`boolean remove(Object o)`	특정 요소를 제거	`boolean`
`boolean contains(Object o)`	특정 요소가 존재하는지 확인	`boolean`
`void clear()`	모든 요소 제거	`void`
`int size()`	저장된 요소의 개수 반환	`int`
`boolean isEmpty()`	비어있는지 확인	`boolean`
`Iterator<E> iterator()`	`Iterator`를 반환하여 요소 순회 가능	`Iterator<E>`
`Object[] toArray()`	요소를 배열로 변환	`Object[]`
`<T> T[] toArray(T[] a)`	특정 타입 배열로 변환	`T[]`

TreeSet

NavigableSet 인터페이스를 구현한 정렬된 집합(Set)

특징

중복을 허용하지 않음
요소가 자동으로 정렬됨 (기본적으로 오름차순 정렬)
내부적으로 Red-Black Tree(레드-블랙 트리)를 기반으로 동작
O(log N)의 시간 복잡도로 검색, 추가, 삭제 가능
정렬 기준 변경 가능 (Comparable 또는 Comparator 사용)
동기화되지 않음 → 멀티스레드 환경에서는 Collections.synchronizedSortedSet() 사용 필요

TreeSet의 생성자

생성자	설명
`TreeSet()`	기본 정렬 기준(오름차순)으로 `TreeSet` 생성
`TreeSet(Comparator<? super E> comparator)`	사용자 정의 정렬 기준을 사용하여 `TreeSet` 생성
`TreeSet(Collection<? extends E> c)`	주어진 컬렉션의 요소를 포함하는 `TreeSet` 생성
`TreeSet(SortedSet<E> s)`	기존 `SortedSet`의 요소를 포함하는 `TreeSet` 생성

TreeSet의 메서드

메서드	설명	반환 타입
`boolean add(E e)`	요소를 추가 (`중복된 값은 추가되지 않음`)	`boolean`
`boolean remove(Object o)`	특정 요소를 제거	`boolean`
`boolean contains(Object o)`	특정 요소가 존재하는지 확인	`boolean`
`void clear()`	모든 요소 제거	`void`
`int size()`	저장된 요소의 개수 반환	`int`
`boolean isEmpty()`	비어있는지 확인	`boolean`
`Iterator<E> iterator()`	`Iterator`를 반환하여 요소 순회 가능	`Iterator<E>`
`E first()`	첫 번째(최소) 요소 반환	`E`
`E last()`	마지막(최대) 요소 반환	`E`
`E lower(E e)`	지정된 요소보다 작은 요소 중 최대값 반환	`E`
`E higher(E e)`	지정된 요소보다 큰 요소 중 최소값 반환	`E`
`E floor(E e)`	지정된 요소보다 작거나 같은 요소 중 최대값 반환	`E`
`E ceiling(E e)`	지정된 요소보다 크거나 같은 요소 중 최소값 반환	`E`
`SortedSet<E> headSet(E toElement)`	지정된 요소보다 작은 모든 요소 반환	`SortedSet<E>`
`SortedSet<E> tailSet(E fromElement)`	지정된 요소보다 크거나 같은 모든 요소 반환	`SortedSet<E>`
`SortedSet<E> subSet(E fromElement, E toElement)`	특정 범위의 요소 반환	`SortedSet<E>`
`NavigableSet<E> descendingSet()`	내림차순 정렬된 `NavigableSet` 반환	`NavigableSet<E>`

Map

Map : 키와 값을 하나의 쌍으로 묶어서 저장하는 컬렉션. 키는 중복될 수 없지만 값은 중복을 허용한다

Map 인터페이스의 주요 메서드

메서드	설명
`V put(K key, V value)`	키-값 쌍 추가 (이미 존재하는 키면 값 덮어씀)
`V get(Object key)`	특정 키에 해당하는 값 반환 (없으면 `null`)
`V remove(Object key)`	특정 키 삭제 및 해당 값 반환
`boolean containsKey(Object key)`	특정 키가 존재하는지 확인
`boolean containsValue(Object value)`	특정 값이 존재하는지 확인
`int size()`	키-값 쌍 개수 반환
`boolean isEmpty()`	맵이 비어 있는지 확인
`void clear()`	모든 키-값 쌍 제거
`Set<K> keySet()`	모든 키를 `Set` 형태로 반환
`Collection<V> values()`	모든 값을 `Collection` 형태로 반환
`Set<Map.Entry<K, V>> entrySet()`	모든 키-값 쌍을 `Set<Map.Entry<K, V>>` 형태로 반환
`V putIfAbsent(K key, V value)`	특정 키가 없을 때만 값 추가
`V replace(K key, V value)`	특정 키가 존재할 때만 값 변경
`boolean replace(K key, V oldValue, V newValue)`	특정 키가 특정 값일 때만 새 값으로 변경

HashMap

Map 인터페이스를 구현한 키-값(Key-Value) 저장 구조

특징

Key는 중복 불가, Value는 중복 가능
해시 기반 자료구조 (HashTable 기반, 내부적으로 배열 + LinkedList + Tree 구조 사용)
요소의 순서를 보장하지 않음
O(1)의 시간 복잡도로 빠른 검색, 추가, 삭제 가능
null 키와 null 값 허용 (null 키는 한 개만 저장 가능)
동기화되지 않음 → 멀티스레드 환경에서는 Collections.synchronizedMap() 사용 필요

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable {
	transient Entry[] table;
    	...
    static class Entry implements Map.Entry {
    	final Object key;
        Object value;
        	...
    }
}

HashMap의 생성자

생성자	설명
`HashMap()`	기본 초기 용량 `16`, 로드 팩터 `0.75`
`HashMap(int initialCapacity)`	초기 용량을 지정하여 `HashMap` 생성
`HashMap(int initialCapacity, float loadFactor)`	초기 용량과 로드 팩터를 지정
`HashMap(Map<? extends K, ? extends V> m)`	주어진 `Map`의 요소를 포함하는 `HashMap` 생성

HashMap의 주요 메서드

메서드	설명	반환 타입
`V put(K key, V value)`	지정된 키와 값을 추가 (기존 키가 있으면 덮어씀)	`V`
`V get(Object key)`	지정된 키에 해당하는 값을 반환	`V`
`V remove(Object key)`	지정된 키의 값을 제거하고 반환	`V`
`boolean containsKey(Object key)`	특정 키가 존재하는지 확인	`boolean`
`boolean containsValue(Object value)`	특정 값이 존재하는지 확인	`boolean`
`void clear()`	모든 요소 제거	`void`
`int size()`	저장된 요소의 개수 반환	`int`
`boolean isEmpty()`	비어있는지 확인	`boolean`
`Set<K> keySet()`	모든 키를 `Set` 형태로 반환	`Set<K>`
`Collection<V> values()`	모든 값을 `Collection` 형태로 반환	`Collection<V>`
`Set<Map.Entry<K,V>> entrySet()`	`Map.Entry` 형태의 모든 키-값 쌍 반환	`Set<Map.Entry<K,V>>`
`V putIfAbsent(K key, V value)`	특정 키가 없을 경우에만 값을 추가	`V`
`V getOrDefault(Object key, V defaultValue)`	키가 없을 경우 기본값 반환	`V`
`void forEach(BiConsumer<? super K, ? super V> action)`	모든 요소에 대해 특정 동작 수행	`void`

Collection 관련 인터페이스 및 클래스

Iterator, ListIterator, Enumeration

컬렉션에 저장된 요소에 접근하는 데 사용되는 인터페이스

Map은 keySet()이나 entrySet()을 받아와서 사용해야 한다

비교 항목	Iterator	ListIterator	Enumeration
지원 컬렉션	`Collection`, `List`, `Set`	`List`	`Vector`, `Hashtable`
순방향 이동	✅ 가능	✅ 가능	✅ 가능
역방향 이동	❌ 불가능	✅ 가능 (`hasPrevious()`, `previous()`)	❌ 불가능
요소 수정	✅ (`remove()`)	✅ (`add()`, `set()`, `remove()`)	❌ 불가능
동시성 처리	Fail-Fast (동시 수정 시 `ConcurrentModificationException` 발생)	Fail-Fast (Iterator와 동일)	Fail-Safe (예외 발생 X)
사용 방식	`iterator()` 호출 후 사용	`listIterator()` 호출 후 사용	`elements()` 호출 후 사용
주요 메서드	`hasNext()`, `next()`, `remove()`	`hasNext()`, `next()`, `hasPrevious()`, `previous()`, `add()`, `set()`, `remove()`	`hasMoreElements()`, `nextElement()`
적용 예시	모든 컬렉션에서 사용 가능	`List` 인터페이스를 구현한 컬렉션 (`ArrayList`, `LinkedList`)에서만 사용 가능	`Vector`, `Hashtable` 전용 (레거시)

Iterator는 모든 컬렉션에서 순회 가능하지만 역방향 이동 불가
ListIterator는 오직 List에서만 사용 가능하며 양방향 이동 및 수정 가능
Enumeration은 구식(레거시) 방식으로 현재는 Iterator 사용이 권장됨

Iterator의 메서드

메서드	설명	반환 타입	예외 발생 가능성
hasNext()	다음 요소가 존재하는지 확인	`boolean`	없음
next()	다음 요소를 반환하고, 커서를 이동	`E` (요소 타입)	`NoSuchElementException` (더 이상 요소가 없을 경우)
remove()	`next()`로 반환된 요소를 삭제	`void`	`IllegalStateException` (`next()` 호출 없이 사용 시)

예시

Collection<String> list = new ArrayList<>();
Iterator<String> iterator = list.iterator();

while (iterator.hasNext()) {
    String element = iterator.next();
    
    if (element.equals("removeMe")) {
        iterator.remove();
    }
}

list의 타입을 Collection으로 하면 구현체를 쉽게 갈아끼울 수 있다
특정 구현체에만 있는 메서드를 사용하는게 아닌 경우에는 Collection 타입으로 선언하는 게 변경에 유리하다

ListIterator의 메서드

메서드	설명	반환 타입	예외 발생 가능성
hasNext()	다음 요소가 존재하는지 확인	`boolean`	없음
next()	다음 요소를 반환하고, 커서를 이동	`E` (요소 타입)	`NoSuchElementException` (더 이상 요소가 없을 경우)
hasPrevious()	이전 요소가 존재하는지 확인	`boolean`	없음
previous()	이전 요소를 반환하고, 커서를 뒤로 이동	`E` (요소 타입)	`NoSuchElementException` (더 이상 이전 요소가 없을 경우)
nextIndex()	다음 요소의 인덱스를 반환	`int`	없음
previousIndex()	이전 요소의 인덱스를 반환	`int`	없음
remove()	`next()` 또는 `previous()`로 반환된 요소를 삭제	`void`	`IllegalStateException` (`next()` 또는 `previous()` 호출 없이 사용 시)
set(E e)	`next()` 또는 `previous()`로 반환된 요소를 주어진 요소로 변경	`void`	`IllegalStateException` (`next()` 또는 `previous()` 호출 없이 사용 시)
add(E e)	현재 위치에 요소를 추가하고, 커서를 새 요소 뒤로 이동	`void`	없음

Arrays

배열을 다루는 데 유용한 메서드들이 있는 클래스

Arrays의 메서드

메서드	설명	반환 타입	예외 발생 가능성
asList(T... a)	배열을 `List`로 변환 (고정 크기)	`List<T>`	없음
binarySearch(T[] a, T key)	이진 검색을 수행하여 요소의 인덱스를 반환 (`정렬 필수`)	`int`	`ArrayIndexOutOfBoundsException` (잘못된 인덱스 접근 시)
copyOf(T[] original, int newLength)	배열을 지정된 길이로 복사	`T[]`	`NegativeArraySizeException` (음수 크기 입력 시)
copyOfRange(T[] original, int from, int to)	배열의 특정 범위를 복사	`T[]`	`ArrayIndexOutOfBoundsException` (잘못된 범위 지정 시)
equals(T[] a, T[] b)	두 배열이 동일한지 비교	`boolean`	없음
fill(T[] a, T val)	배열의 모든 요소를 특정 값으로 채움	`void`	없음
sort(T[] a)	배열을 오름차순 정렬	`void`	`ClassCastException` (정렬 불가능한 타입일 경우)
sort(T[] a, Comparator<? super T> c)	사용자 정의 정렬 기준으로 정렬	`void`	`ClassCastException` (잘못된 Comparator 사용 시)
toString(T[] a)	배열을 문자열로 변환	`String`	없음
deepEquals(Object[] a, Object[] b)	다차원 배열을 포함하여 배열 비교	`boolean`	없음
deepToString(Object[] a)	다차원 배열을 문자열로 변환	`String`	없음
parallelSort(T[] a)	병렬 정렬 수행 (`멀티코어 환경 최적화`)	`void`	`ClassCastException` (정렬 불가능한 타입일 경우)
stream(T[] array)	배열을 스트림(Stream)으로 변환	`Stream<T>`	없음

Comparator와 Comparable

정렬 기준을 정의할 때 사용하는 인터페이스

public interface Comparator {
	int compare(Object o1, Object o2);
	boolean equals(Object obj);
}

public interface Comparable {
	int compareTo(Object o);
}

Comparator vs. Comparable

비교 항목	Comparable	Comparator
패키지	`java.lang`	`java.util`
정렬 방식 정의 위치	클래스 내부에서 정렬 기준 정의 (`compareTo()`)	클래스 외부에서 정렬 기준 정의 (`compare()`)
정렬 기준 수	단일 기준 정렬만 가능	여러 기준으로 정렬 가능 (다중 정렬 지원)
인터페이스 선언	`class A implements Comparable<A>`	`class AComparator implements Comparator<A>`
메서드	`int compareTo(T o)`	`int compare(T o1, T o2)`
기본 정렬 적용 여부	기본 정렬(자연 정렬, Natural Ordering) 적용	기본 정렬 없음 (정렬 시 Comparator 필요)
사용 예시	`Collections.sort(list);`	`Collections.sort(list, new MyComparator());`

Comparable 예시

class Person implements Comparable<Person> {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age); // 나이 오름차순 정렬
    }
}


List<Person> people = new ArrayList<>();
people.add(new Person("Alice", 25));
people.add(new Person("Bob", 20));
Collections.sort(people); // 나이 기준 오름차순 정렬

Comparator 예시

class NameComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.name.compareTo(p2.name); // 이름 오름차순 정렬
    }
}

Collections.sort(people, new NameComparator()); // 이름 기준 정렬

허경두

다음 포스트