Light Blue Pointer
본문 바로가기
Developing/TIL(Develop)

Collection Framework

by Greedy 2024. 5. 24.

Java Collection Framework는 데이터를 저장하고 조작하는 데 사용되는 클래스와 인터페이스의 표준화된 구조이다

다양한 데이터 구조를 쉽게 사용할 수 있고, 데이터 조작을 간편하게 수행할 수 있게 한다

주요 인터페이스와 클래스

1. 인터페이스

 

Collection 모든 컬렉션 클래스의 최상위 인터페이스.

List 순서가 있는 컬렉션을 나타내며, 중복 요소를 허용.

  • 구현 클래스: ArrayList, LinkedList, Vector, Stack

Set 순서가 없는 컬렉션을 나타내며, 중복 요소를 허용하지 않음.

  • 구현 클래스: HashSet, LinkedHashSet, TreeSet

Queue FIFO(First In First Out) 구조를 나타내며, 주로 큐와 같은 데이터 구조를 나타냄.

  • 구현 클래스: LinkedList, PriorityQueue

Deque 양쪽 끝에서 요소를 추가하고 제거할 수 있는 큐.

  • 구현 클래스: ArrayDeque, LinkedList

Map 키-값 쌍으로 이루어진 컬렉션.

  • 구현 클래스: HashMap, LinkedHashMap, TreeMap, Hashtable

2. 클래스

ArrayList 크기가 가변적인 배열로, 요소의 인덱스 기반 접근이 가능.

LinkedList 이중 연결 리스트로, 빠른 삽입과 삭제가 가능.

HashSet 해시 테이블 기반의 Set 구현체로, 요소의 순서가 유지되지 않음.

TreeSet 이진 트리 기반의 Set 구현체로, 요소가 정렬된 상태로 저장.

HashMap 해시 테이블 기반의 Map 구현체로, 키와 값의 순서가 유지되지 않음.

TreeMap 이진 트리 기반의 Map 구현체로, 키가 정렬된 상태로 저장.

주요 메서드

Collection 인터페이스

add(E e): 컬렉션에 요소를 추가.

remove(Object o): 컬렉션에서 특정 요소를 제거.

clear(): 컬렉션의 모든 요소를 제거.

size(): 컬렉션의 요소 개수를 반환.

isEmpty(): 컬렉션이 비어 있는지 여부를 반환.

contains(Object o): 특정 요소가 컬렉션에 포함되어 있는지 여부를 반환.

iterator(): 컬렉션의 요소에 대해 반복하는 Iterator를 반환.

List 인터페이스

get(int index): 주어진 인덱스의 요소를 반환.

set(int index, E element): 주어진 인덱스의 요소를 변경.

add(int index, E element): 주어진 인덱스에 요소를 추가.

remove(int index): 주어진 인덱스의 요소를 제거.

indexOf(Object o): 특정 요소의 인덱스를 반환.

lastIndexOf(Object o): 특정 요소의 마지막 인덱스를 반환.

listIterator(): 리스트의 요소에 대해 반복하는 ListIterator를 반환.

Set 인터페이스

SetCollection 인터페이스의 모든 메서드를 상속받으며, 요소의 순서를 보장하지 않음.

Queue 인터페이스

offer(E e): 큐의 끝에 요소를 추가.

poll(): 큐의 앞에서 요소를 제거하고 반환.

peek(): 큐의 앞 요소를 제거하지 않고 반환.

Map 인터페이스

put(K key, V value): 주어진 키와 값을 맵에 추가.

get(Object key): 주어진 키에 해당하는 값을 반환.

remove(Object key): 주어진 키에 해당하는 키-값 쌍을 제거.

containsKey(Object key): 특정 키가 맵에 포함되어 있는지 여부를 반환.

containsValue(Object value): 특정 값이 맵에 포함되어 있는지 여부를 반환.

keySet(): 맵의 모든 키를 포함하는 Set을 반환.

values(): 맵의 모든 값을 포함하는 Collection을 반환.

entrySet(): 맵의 모든 키-값 쌍을 포함하는 Set을 반환.

import java.util.*;

public class CollectionExample {
    public static void main(String[] args) {
        // List 예시
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Apple");
        arrayList.add("Banana");
        arrayList.add("Cherry");
        System.out.println("ArrayList: " + arrayList);

        // Set 예시
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Apple");
        hashSet.add("Banana");
        hashSet.add("Apple"); // 중복 요소는 추가되지 않음
        System.out.println("HashSet: " + hashSet);

        // Queue 예시
        Queue<String> priorityQueue = new PriorityQueue<>();
        priorityQueue.add("Apple");
        priorityQueue.add("Banana");
        priorityQueue.add("Cherry");
        System.out.println("PriorityQueue: " + priorityQueue);
        System.out.println("Poll: " + priorityQueue.poll());
        System.out.println("PriorityQueue after poll: " + priorityQueue);

        // Map 예시
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Apple", 1);
        hashMap.put("Banana", 2);
        hashMap.put("Cherry", 3);
        System.out.println("HashMap: " + hashMap);
    }
}

Collection Framework의 장점

표준화된 인터페이스: 다양한 데이터 구조에 대해 일관된 인터페이스를 제공하여 학습과 사용이 용이.

재사용성: 다양한 상황에 맞는 데이터 구조를 재사용 가능.

성능 최적화: 자주 사용되는 데이터 구조와 알고리즘이 최적화되어 제공.

타입 안정성: 제네릭스를 통해 컴파일 시 타입 검사를 강화하여 타입 안전성을 제공.

 

Java Collection Framework는 데이터 구조를 효과적으로 관리하고 조작하는 데 있어 강력한 도구를 제공한다.

이를 통해 개발자는 복잡한 데이터 구조를 쉽게 구현하고 사용할 수 있다.

Java Collection Framework에서 제공하는 다양한 데이터 구조의 주요 연산(삽입, 삭제, 조회)의 시간 복잡도는 각 데이터 구조의 구현 방식에 따라 다르다.

Java Collection Framework의 주요 데이터 구조와 관련된 연산의 시간 복잡도

Collection Type Operation Average Time Complexity

ArrayList add(E element) O(1)
  add(int index, E element) O(n)
  get(int index) O(1)
  remove(int index) O(n)
  remove(Object o) O(n)
  contains(Object o) O(n)
  size() O(1)
LinkedList add(E element) O(1)
  add(int index, E element) O(n)
  get(int index) O(n)
  remove(int index) O(n)
  remove(Object o) O(n)
  contains(Object o) O(n)
  size() O(1)
HashSet add(E element) O(1)
  remove(Object o) O(1)
  contains(Object o) O(1)
  size() O(1)
TreeSet add(E element) O(log n)
  remove(Object o) O(log n)
  contains(Object o) O(log n)
  size() O(1)
PriorityQueue offer(E e) O(log n)
  poll() O(log n)
  peek() O(1)
  size() O(1)
ArrayDeque addFirst(E e) O(1)
  addLast(E e) O(1)
  removeFirst() O(1)
  removeLast() O(1)
  peekFirst() O(1)
  peekLast() O(1)
  size() O(1)
HashMap put(K key, V value) O(1)
  get(Object key) O(1)
  remove(Object key) O(1)
  containsKey(Object key) O(1)
  size() O(1)
TreeMap put(K key, V value) O(log n)
  get(Object key) O(log n)
  remove(Object key) O(log n)
  containsKey(Object key) O(log n)
  size() O(1)