elex/java-examples
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
dfee41a74094d9927e6f2dac00a9bd0e8d4fb26e
java-examples/docs/Collection Framework.md

13 KiB
Raw Blame History

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 사용 예제

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() - 정렬

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를 사용하면 정렬 기준을 변경할 수 있다.
Collections.sort(list, Comparator.reverseOrder()); // 내림차순 정렬

✔ binarySearch() - 이진 탐색

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() - 무작위 섞기

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() - 최소값과 최대값 찾기

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() - 모든 요소를 특정 값으로 채우기

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() - 특정 값 치환

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() - 특정 값 개수 세기

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() - 동기화 리스트

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() - 불변 리스트

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 컬렉션을 더욱 편리하게 다룰 수 있다! 🚀

Reference in New Issue View Git Blame Copy Permalink