380 lines
13 KiB
Markdown
380 lines
13 KiB
Markdown
# **Java의 List, Set, Queue, Deque, Map 인터페이스 및 구현 클래스 비교**
|
||
|
||
Java의 **Collection Framework**는 데이터를 효율적으로 저장하고 관리할 수 있는 다양한 자료구조를 제공한다.
|
||
그중에서 `List`, `Set`, `Queue`, `Deque`, `Map` 인터페이스는 각기 다른 특성을 가지며,
|
||
이를 구현하는 여러 클래스가 존재한다.
|
||
|
||
---
|
||
|
||
## **📌 1. 인터페이스별 메서드 정리**
|
||
|
||
### **1️⃣ List 인터페이스 (순서 유지, 중복 허용)**
|
||
| 메서드 | 설명 |
|
||
|--------|------|
|
||
| `void add(int index, E element)` | 특정 위치에 요소 삽입 |
|
||
| `boolean add(E element)` | 리스트 끝에 요소 추가 |
|
||
| `E get(int index)` | 특정 위치의 요소 반환 |
|
||
| `E remove(int index)` | 특정 위치의 요소 삭제 |
|
||
| `boolean remove(Object o)` | 특정 요소 삭제 |
|
||
| `int indexOf(Object o)` | 특정 요소의 첫 번째 인덱스 반환 |
|
||
| `int lastIndexOf(Object o)` | 특정 요소의 마지막 인덱스 반환 |
|
||
| `List<E> subList(int fromIndex, int toIndex)` | 특정 범위의 부분 리스트 반환 |
|
||
|
||
#### **구현 클래스 비교**
|
||
| 클래스 | 특징 |
|
||
|--------|------|
|
||
| `ArrayList<E>` | 배열 기반, 인덱스 접근 빠름, 삽입/삭제 느림 |
|
||
| `LinkedList<E>` | 이중 연결 리스트, 삽입/삭제 빠름, 인덱스 접근 느림 |
|
||
| `Vector<E>` | `ArrayList`와 유사하지만 동기화(Synchronized) 지원 |
|
||
| `Stack<E>` | `Vector`를 상속받아 LIFO(후입선출) 기능 제공 |
|
||
|
||
---
|
||
|
||
### **2️⃣ Set 인터페이스 (중복 허용 X, 순서 보장 X)**
|
||
| 메서드 | 설명 |
|
||
|--------|------|
|
||
| `boolean add(E e)` | 요소 추가 (중복이면 추가되지 않음) |
|
||
| `boolean remove(Object o)` | 특정 요소 제거 |
|
||
| `boolean contains(Object o)` | 특정 요소 포함 여부 확인 |
|
||
| `int size()` | 요소 개수 반환 |
|
||
| `void clear()` | 모든 요소 제거 |
|
||
|
||
#### **구현 클래스 비교**
|
||
| 클래스 | 특징 |
|
||
|--------|------|
|
||
| `HashSet<E>` | 해시 테이블 기반, 요소 순서 유지 X, 검색 빠름 |
|
||
| `LinkedHashSet<E>` | `HashSet`과 같지만 요소 삽입 순서 유지 |
|
||
| `TreeSet<E>` | 이진 탐색 트리 기반, 요소가 **자동 정렬됨** |
|
||
|
||
---
|
||
|
||
### **3️⃣ Queue 인터페이스 (FIFO, 선입선출 구조)**
|
||
| 메서드 | 설명 |
|
||
|--------|------|
|
||
| `boolean add(E e)` | 요소 추가 (실패 시 예외 발생) |
|
||
| `boolean offer(E e)` | 요소 추가 (실패 시 false 반환) |
|
||
| `E remove()` | 첫 번째 요소 제거 (큐가 비었으면 예외 발생) |
|
||
| `E poll()` | 첫 번째 요소 제거 (큐가 비었으면 null 반환) |
|
||
| `E element()` | 첫 번째 요소 반환 (큐가 비었으면 예외 발생) |
|
||
| `E peek()` | 첫 번째 요소 반환 (큐가 비었으면 null 반환) |
|
||
|
||
#### **구현 클래스 비교**
|
||
| 클래스 | 특징 |
|
||
|--------|------|
|
||
| `LinkedList<E>` | `Queue` 인터페이스 구현, 양방향 리스트 구조 |
|
||
| `PriorityQueue<E>` | 내부적으로 힙(Heap) 사용, **우선순위에 따라 정렬** |
|
||
| `ArrayDeque<E>` | 양방향 큐 (Deque) 지원, `Stack` 대체 가능 |
|
||
|
||
---
|
||
|
||
### **4️⃣ Deque 인터페이스 (양방향 큐)**
|
||
| 메서드 | 설명 |
|
||
|--------|------|
|
||
| `void addFirst(E e)` | 앞쪽에 요소 추가 |
|
||
| `void addLast(E e)` | 뒤쪽에 요소 추가 |
|
||
| `E removeFirst()` | 앞쪽 요소 제거 |
|
||
| `E removeLast()` | 뒤쪽 요소 제거 |
|
||
| `E getFirst()` | 첫 번째 요소 반환 |
|
||
| `E getLast()` | 마지막 요소 반환 |
|
||
| `boolean offerFirst(E e)` | 앞쪽에 요소 추가 (실패 시 false 반환) |
|
||
| `boolean offerLast(E e)` | 뒤쪽에 요소 추가 (실패 시 false 반환) |
|
||
|
||
#### **구현 클래스 비교**
|
||
| 클래스 | 특징 |
|
||
|--------|------|
|
||
| `ArrayDeque<E>` | 배열 기반, 크기 자동 조절 |
|
||
| `LinkedList<E>` | 이중 연결 리스트 기반 |
|
||
|
||
---
|
||
|
||
### **5️⃣ Map 인터페이스 (키-값 쌍 저장, 중복 키 X)**
|
||
| 메서드 | 설명 |
|
||
|--------|------|
|
||
| `V put(K key, V value)` | 키-값 쌍 추가 (같은 키가 존재하면 기존 값 덮어쓰기) |
|
||
| `V get(Object key)` | 특정 키에 대한 값 반환 |
|
||
| `V remove(Object key)` | 특정 키의 값 삭제 |
|
||
| `boolean containsKey(Object key)` | 특정 키 포함 여부 확인 |
|
||
| `boolean containsValue(Object value)` | 특정 값 포함 여부 확인 |
|
||
| `Set<K> keySet()` | 모든 키 반환 |
|
||
| `Collection<V> values()` | 모든 값 반환 |
|
||
| `Set<Map.Entry<K,V>> entrySet()` | 모든 키-값 쌍 반환 |
|
||
|
||
#### **구현 클래스 비교**
|
||
| 클래스 | 특징 |
|
||
|--------|------|
|
||
| `HashMap<K,V>` | 해시 테이블 기반, 키 순서 보장 X, 빠른 검색 |
|
||
| `LinkedHashMap<K,V>` | 삽입 순서 유지 |
|
||
| `TreeMap<K,V>` | 키 기준으로 **자동 정렬** |
|
||
|
||
---
|
||
|
||
## **📌 2. 구현 클래스 비교 요약**
|
||
| 인터페이스 | 주요 구현 클래스 | 특징 |
|
||
|------------|--------------|------|
|
||
| `List` | `ArrayList` | 배열 기반, 빠른 조회, 삽입/삭제 느림 |
|
||
| | `LinkedList` | 연결 리스트 기반, 삽입/삭제 빠름, 조회 느림 |
|
||
| | `Vector` | `ArrayList`와 유사하지만 동기화 지원 |
|
||
| | `Stack` | `Vector`를 확장하여 LIFO(후입선출) 제공 |
|
||
| `Set` | `HashSet` | 중복 X, 순서 보장 X |
|
||
| | `LinkedHashSet` | 삽입 순서 유지 |
|
||
| | `TreeSet` | 자동 정렬 (오름차순) |
|
||
| `Queue` | `LinkedList` | FIFO (선입선출) |
|
||
| | `PriorityQueue` | 우선순위 기반 정렬 |
|
||
| | `ArrayDeque` | 양방향 큐 (Deque) |
|
||
| `Deque` | `ArrayDeque` | 배열 기반, 크기 자동 조절 |
|
||
| | `LinkedList` | 연결 리스트 기반 |
|
||
| `Map` | `HashMap` | 중복 키 X, 순서 보장 X |
|
||
| | `LinkedHashMap` | 삽입 순서 유지 |
|
||
| | `TreeMap` | 키 기준 자동 정렬 |
|
||
|
||
---
|
||
|
||
## **📌 3. 예제 코드**
|
||
### **✔ `List` 사용 예제**
|
||
```java
|
||
import java.util.*;
|
||
|
||
public class ListExample {
|
||
public static void main(String[] args) {
|
||
List<String> list = new ArrayList<>();
|
||
list.add("Apple");
|
||
list.add("Banana");
|
||
list.add("Cherry");
|
||
|
||
System.out.println(list.get(1)); // 출력: Banana
|
||
list.remove("Banana");
|
||
System.out.println(list); // 출력: [Apple, Cherry]
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## **📌 4. 마무리**
|
||
✔ **List**: 순서 유지, 중복 허용
|
||
✔ **Set**: 순서 없음, 중복 불가
|
||
✔ **Queue**: FIFO 구조, `PriorityQueue`는 우선순위 정렬
|
||
✔ **Deque**: 양방향 큐
|
||
✔ **Map**: 키-값 저장, 키 중복 불가
|
||
✔ 각 자료구조의 **특성을 이해하고 상황에 맞게 선택**하자! 🚀
|
||
|
||
|
||
---
|
||
|
||
# **Java 컬렉션 유틸리티 클래스 (Collections, Arrays, etc.)**
|
||
|
||
Java에서는 컬렉션을 쉽게 다룰 수 있도록 **유틸리티 클래스**를 제공한다.
|
||
대표적으로 `Collections`와 `Arrays` 클래스가 있으며, 이들은 **정렬, 검색, 동기화, 불변 컬렉션 생성** 등의 기능을 제공한다.
|
||
|
||
---
|
||
|
||
## **📌 1. Collections 클래스의 주요 메서드 정리**
|
||
| 메서드 | 설명 |
|
||
|--------|------|
|
||
| `sort(List<T> list)` | 오름차순 정렬 |
|
||
| `sort(List<T> list, Comparator<? super T> c)` | 지정한 정렬 기준으로 정렬 |
|
||
| `binarySearch(List<T> list, T key)` | 이진 탐색 (정렬된 리스트에서만 사용 가능) |
|
||
| `reverse(List<?> list)` | 리스트 요소 순서를 반대로 변경 |
|
||
| `shuffle(List<?> list)` | 리스트 요소를 무작위로 섞음 |
|
||
| `min(Collection<? extends T> coll)` | 컬렉션에서 최소값 반환 |
|
||
| `max(Collection<? extends T> coll)` | 컬렉션에서 최대값 반환 |
|
||
| `fill(List<? super T> list, T obj)` | 리스트의 모든 요소를 특정 값으로 채움 |
|
||
| `copy(List<? super T> dest, List<? extends T> src)` | 리스트 복사 |
|
||
| `replaceAll(List<T> list, T oldVal, T newVal)` | 특정 값을 새로운 값으로 대체 |
|
||
| `frequency(Collection<?> c, Object o)` | 특정 요소가 컬렉션에 몇 번 등장하는지 반환 |
|
||
| `disjoint(Collection<?> c1, Collection<?> c2)` | 두 컬렉션이 공통 요소를 가지지 않으면 `true` 반환 |
|
||
| `synchronizedList(List<T> list)` | 동기화된 리스트 반환 |
|
||
| `synchronizedSet(Set<T> set)` | 동기화된 셋 반환 |
|
||
| `synchronizedMap(Map<K,V> map)` | 동기화된 맵 반환 |
|
||
| `synchronizedSortedMap(SortedMap<K,V> map)` | 동기화된 정렬된 맵 반환 |
|
||
| `unmodifiableList(List<? extends T> list)` | 불변 리스트 반환 |
|
||
| `unmodifiableSet(Set<? extends T> set)` | 불변 셋 반환 |
|
||
| `unmodifiableMap(Map<? extends K,? extends V> map)` | 불변 맵 반환 |
|
||
|
||
---
|
||
|
||
## **📌 2. Arrays 클래스의 주요 메서드 정리**
|
||
| 메서드 | 설명 |
|
||
|--------|------|
|
||
| `sort(T[] array)` | 배열 정렬 (오름차순) |
|
||
| `sort(T[] array, Comparator<? super T> c)` | 사용자 정의 비교 기준으로 정렬 |
|
||
| `binarySearch(T[] array, T key)` | 배열에서 이진 탐색 수행 |
|
||
| `fill(T[] array, T val)` | 배열의 모든 요소를 특정 값으로 채움 |
|
||
| `copyOf(T[] original, int newLength)` | 배열을 새로운 크기로 복사 |
|
||
| `copyOfRange(T[] original, int from, int to)` | 배열의 특정 범위를 복사 |
|
||
| `equals(T[] a, T[] b)` | 두 배열이 같은지 비교 |
|
||
| `deepEquals(Object[] a, Object[] b)` | 다차원 배열 비교 |
|
||
| `asList(T... a)` | 배열을 리스트로 변환 |
|
||
| `toString(T[] a)` | 배열을 문자열로 변환 |
|
||
|
||
---
|
||
|
||
## **📌 3. 주요 메서드 설명 및 예제**
|
||
|
||
### **✔ `sort()` - 정렬**
|
||
```java
|
||
import java.util.*;
|
||
|
||
public class SortExample {
|
||
public static void main(String[] args) {
|
||
List<Integer> list = Arrays.asList(5, 3, 8, 1, 2);
|
||
Collections.sort(list);
|
||
System.out.println(list); // 출력: [1, 2, 3, 5, 8]
|
||
}
|
||
}
|
||
```
|
||
- 기본적으로 **오름차순 정렬**한다.
|
||
- `Comparator`를 사용하면 정렬 기준을 변경할 수 있다.
|
||
|
||
```java
|
||
Collections.sort(list, Comparator.reverseOrder()); // 내림차순 정렬
|
||
```
|
||
|
||
---
|
||
|
||
### **✔ `binarySearch()` - 이진 탐색**
|
||
```java
|
||
import java.util.*;
|
||
|
||
public class BinarySearchExample {
|
||
public static void main(String[] args) {
|
||
List<Integer> list = Arrays.asList(1, 2, 3, 5, 8);
|
||
int index = Collections.binarySearch(list, 3);
|
||
System.out.println("Index of 3: " + index); // 출력: Index of 3: 2
|
||
}
|
||
}
|
||
```
|
||
- **정렬된 리스트에서만 사용 가능**하다.
|
||
- 찾는 값이 없으면 **음수 반환**.
|
||
|
||
---
|
||
|
||
### **✔ `shuffle()` - 무작위 섞기**
|
||
```java
|
||
import java.util.*;
|
||
|
||
public class ShuffleExample {
|
||
public static void main(String[] args) {
|
||
List<String> list = Arrays.asList("A", "B", "C", "D");
|
||
Collections.shuffle(list);
|
||
System.out.println(list); // 매 실행마다 다른 순서
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### **✔ `min()` / `max()` - 최소값과 최대값 찾기**
|
||
```java
|
||
import java.util.*;
|
||
|
||
public class MinMaxExample {
|
||
public static void main(String[] args) {
|
||
List<Integer> list = Arrays.asList(3, 8, 1, 5, 2);
|
||
System.out.println(Collections.min(list)); // 출력: 1
|
||
System.out.println(Collections.max(list)); // 출력: 8
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### **✔ `fill()` - 모든 요소를 특정 값으로 채우기**
|
||
```java
|
||
import java.util.*;
|
||
|
||
public class FillExample {
|
||
public static void main(String[] args) {
|
||
List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
|
||
Collections.fill(list, "X");
|
||
System.out.println(list); // 출력: [X, X, X]
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### **✔ `replaceAll()` - 특정 값 치환**
|
||
```java
|
||
import java.util.*;
|
||
|
||
public class ReplaceAllExample {
|
||
public static void main(String[] args) {
|
||
List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "apple"));
|
||
Collections.replaceAll(list, "apple", "orange");
|
||
System.out.println(list); // 출력: [orange, banana, orange]
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### **✔ `frequency()` - 특정 값 개수 세기**
|
||
```java
|
||
import java.util.*;
|
||
|
||
public class FrequencyExample {
|
||
public static void main(String[] args) {
|
||
List<String> list = Arrays.asList("apple", "banana", "apple", "cherry", "apple");
|
||
System.out.println(Collections.frequency(list, "apple")); // 출력: 3
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### **✔ `synchronizedList()` - 동기화 리스트**
|
||
```java
|
||
import java.util.*;
|
||
|
||
public class SynchronizedListExample {
|
||
public static void main(String[] args) {
|
||
List<Integer> list = Collections.synchronizedList(new ArrayList<>());
|
||
|
||
synchronized (list) {
|
||
list.add(1);
|
||
list.add(2);
|
||
list.add(3);
|
||
}
|
||
|
||
System.out.println(list); // 출력: [1, 2, 3]
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### **✔ `unmodifiableList()` - 불변 리스트**
|
||
```java
|
||
import java.util.*;
|
||
|
||
public class UnmodifiableListExample {
|
||
public static void main(String[] args) {
|
||
List<String> list = Arrays.asList("A", "B", "C");
|
||
List<String> unmodifiableList = Collections.unmodifiableList(list);
|
||
|
||
unmodifiableList.add("D"); // 예외 발생
|
||
}
|
||
}
|
||
```
|
||
- `unmodifiableList`는 **수정 불가**.
|
||
|
||
---
|
||
|
||
## **📌 4. 정리**
|
||
| 기능 | Collections 메서드 | Arrays 메서드 |
|
||
|------|----------------|------------|
|
||
| 정렬 | `sort()` | `sort()` |
|
||
| 검색 | `binarySearch()` | `binarySearch()` |
|
||
| 최소/최대값 | `min()`, `max()` | X |
|
||
| 무작위 섞기 | `shuffle()` | X |
|
||
| 요소 채우기 | `fill()` | `fill()` |
|
||
| 요소 치환 | `replaceAll()` | X |
|
||
| 특정 값 개수 | `frequency()` | X |
|
||
| 동기화 컬렉션 | `synchronizedList()` | X |
|
||
| 불변 컬렉션 | `unmodifiableList()` | X |
|
||
|
||
✔ `Collections`는 **컬렉션(List, Set, Map) 관련 기능** 제공
|
||
✔ `Arrays`는 **배열 관련 기능** 제공
|
||
|
||
이제 Java 컬렉션을 더욱 편리하게 다룰 수 있다! 🚀 |