컬렉션 프레임워크(collection framework)란?
자바에서 컬렉션 프레임워크(collection framework)란 다수의 데이터를 쉽고 효과적으로 처리할 수 있는 표준화된 방법을 제공하는 클래스의 집합을 의미합니다
즉, 데이터를 저장하는 자료 구조와 데이터를 처리하는 알고리즘을 구조화하여 클래스로 구현해 놓은 것입니다.
이러한 컬렉션 프레임워크는 자바의 인터페이스(interface)를 사용하여 구현됩니다.
컬렉션 프레임워크 주요 인터페이스
컬렉션 프레임워크에서는 데이터를 저장하는 자료 구조에 따라 다음과 같은 핵심이 되는 주요 인터페이스를 정의하고 있습니다.
1. List 인터페이스
2. Set 인터페이스
3. Map 인터페이스
이 중에서 List와 Set 인터페이스는 모두 Collection 인터페이스를 상속받지만, 구조상의 차이로 인해 Map 인터페이스는 별도로 정의됩니다.
따라서 List 인터페이스와 Set 인터페이스의 공통된 부분을 Collection 인터페이스에서 정의하고 있습니다.
주요 인터페이스의 간략한 특징
자바에서 컬렉션 프레임워크를 구성하고 있는 주요 인터페이스의 간략한 특징은 다음과 같습니다.
|
인터페이스 |
설명 |
구현 클래스 |
|
List<E> |
순서가 있는 데이터의 집합으로, 데이터의 중복을 허용함. |
Vector, ArrayList, LinkedList, Stack, Queue |
|
Set<E> |
순서가 없는 데이터의 집합으로, 데이터의 중복을 허용하지 않음. |
HashSet, TreeSet |
|
Map<K, V> |
키와 값의 한 쌍으로 이루어지는 데이터의 집합으로, 순서가 없음. 이때 키는 중복을 허용하지 않지만, 값은 중복될 수 있음. |
HashMap, TreeMap, Hashtable, Properties |
컬렉션 클래스(collection class)
컬렉션 프레임워크에 속하는 인터페이스를 구현한 클래스를 컬렉션 클래스(collection class)라고 합니다.
컬렉션 프레임워크의 모든 컬렉션 클래스는 List와 Set, Map 인터페이스 중 하나의 인터페이스를 구현하고 있습니다.
또한, 클래스 이름에도 구현한 인터페이스의 이름이 포함되므로 바로 구분할 수 있습니다.
Vector나 Hashtable과 같은 컬렉션 클래스는 예전부터 사용해 왔으므로, 기존 코드와의 호환을 위해 아직도 남아 있습니다.
하지만 기존에 사용하던 컬렉션 클래스를 사용하는 것보다는 새로 추가된 ArrayList나 HashMap 클래스를 사용하는 것이 성능 면에서도 더 나은 결과를 얻을 수 있습니다.
다음 예제는 ArrayList 클래스를 이용하여 리스트를 생성하고 조작하는 예제입니다.
예제
import java.util.*;
public class Collection01 {
public static void main(String[] args) {
// 리스트 생성
ArrayList<String> arrList = new ArrayList<String>();
// 리스트에 요소의 저장
arrList.add("넷");
arrList.add("둘");
arrList.add("셋");
arrList.add("하나");
// 리스트 요소의 출력
for(int i = 0; i < arrList.size(); i++) {
System.out.println(arrList.get(i));
}
}
}
Collection 인터페이스
List와 Set 인터페이스의 많은 공통된 부분을 Collection 인터페이스에서 정의하고, 두 인터페이스는 그것을 상속받습니다.
따라서 Collection 인터페이스는 컬렉션을 다루는데 가장 기본적인 동작들을 정의하고, 그것을 메소드로 제공하고 있습니다.
Collection 인터페이스에서 제공하는 주요 메소드는 다음과 같습니다.
|
메소드 |
설명 |
|
boolean add(E e) |
해당 컬렉션(collection)에 전달된 요소를 추가함. (선택적 기능) |
|
void clear() |
해당 컬렉션의 모든 요소를 제거함. (선택적 기능) |
|
boolean contains(Object o) |
해당 컬렉션이 전달된 객체를 포함하고 있는지를 확인함. |
|
boolean equals(Object o) |
해당 컬렉션과 전달된 객체가 같은지를 확인함. |
|
boolean isEmpty() |
해당 컬렉션이 비어있는지를 확인함. |
|
Iterator<E> iterator() |
해당 컬렉션의 반복자(iterator)를 반환함. |
|
boolean remove(Object o) |
해당 컬렉션에서 전달된 객체를 제거함. (선택적 기능) |
|
int size() |
해당 컬렉션의 요소의 총 개수를 반환함. |
|
Object[] toArray() |
해당 컬렉션의 모든 요소를 Object 타입의 배열로 반환함. |
List 컬렉션 클래스
List 인터페이스를 구현한 모든 List 컬렉션 클래스는 다음과 같은 특징을 가집니다.
1. 요소의 저장 순서가 유지됩니다.
2. 같은 요소의 중복 저장을 허용합니다.
대표적인 List 컬렉션 클래스에 속하는 클래스는 다음과 같습니다.
1. ArrayList<E>
2. LinkedList<E>
3. Vector<E>
4. Stack<E>
ArrayList<E> 클래스
ArrayList 클래스는 가장 많이 사용되는 컬렉션 클래스 중 하나입니다.
JDK 1.2부터 제공된 ArrayList 클래스는 내부적으로 배열을 이용하여 요소를 저장합니다.
ArrayList 클래스는 배열을 이용하기 때문에 인덱스를 이용해 배열 요소에 빠르게 접근할 수 있습니다.
하지만 배열은 크기를 변경할 수 없는 인스턴스이므로, 크기를 늘리기 위해서는 새로운 배열을 생성하고 기존의 요소들을 옮겨야 하는 복잡한 과정을 거쳐야 합니다.
물론 이 과정은 자동으로 수행되지만, 요소의 추가 및 삭제 작업에 걸리는 시간이 매우 길어지는 단점을 가지게 됩니다.
다음 예제는 여러 ArrayList 메소드를 이용하여 리스트를 생성하고 조작하는 예제입니다.
예제
ArrayList<Integer> arrList = new ArrayList<Integer>();
// add() 메소드를 이용한 요소의 저장
arrList.add(40);
arrList.add(20);
arrList.add(30);
arrList.add(10);
// for 문과 get() 메소드를 이용한 요소의 출력
for (int i = 0; i < arrList.size(); i++) {
System.out.print(arrList.get(i) + " ");
}
// remove() 메소드를 이용한 요소의 제거
arrList.remove(1);
// Enhanced for 문과 get() 메소드를 이용한 요소의 출력
for (int e : arrList) {
System.out.print(e + " ");
}
// Collections.sort() 메소드를 이용한 요소의 정렬
Collections.sort(arrList);
// iterator() 메소드와 get() 메소드를 이용한 요소의 출력
Iterator<Integer> iter = arrList.iterator();
while (iter.hasNext()) {
System.out.print(iter.next() + " ");
}
// set() 메소드를 이용한 요소의 변경
arrList.set(0, 20);
for (int e : arrList) {
System.out.print(e + " ");
}
// size() 메소드를 이용한 요소의 총 개수
System.out.println("리스트의 크기 : " + arrList.size());
위 예제처럼 컬렉션 클래스의 요소를 출력하는 방법에는 for 문과 enhanced for 문, iterator() 메소드를 이용한 방법 등 다양한 방법을 사용할 수 있습니다.
자바의 Collections 클래스는 JDK 1.2부터 제공되는 컬렉션에서 동작하거나 컬렉션을 반환하는 클래스 메소드(static method)만으로 구성된 클래스입니다.
자바의 Collection은 인터페이스이며, Collections는 클래스임을 주의해야 합니다.
LinkedList<E> 클래스
LinkedList 클래스는 ArrayList 클래스가 배열을 이용하여 요소를 저장함으로써 발생하는 단점을 극복하기 위해 고안되었습니다.
JDK 1.2부터 제공된 LinkedList 클래스는 내부적으로 연결 리스트(linked list)를 이용하여 요소를 저장합니다.
배열은 저장된 요소가 순차적으로 저장됩니다.
하지만 연결 리스트는 저장된 요소가 비순차적으로 분포되며, 이러한 요소들 사이를 링크(link)로 연결하여 구성합니다.
다음 요소를 가리키는 참조만을 가지는 연결 리스트를 단일 연결 리스트(singly linked list)라고 합니다.
이러한 단일 연결 리스트는 요소의 저장과 삭제 작업이 다음 요소를 가리키는 참조만 변경하면 되므로, 아주 빠르게 처리될 수 있습니다.
하지만 단일 연결 리스트는 현재 요소에서 이전 요소로 접근하기가 매우 어렵습니다.
따라서 이전 요소를 가리키는 참조도 가지는 이중 연결 리스트(doubly linked list)가 좀 더 많이 사용됩니다.
LinkedList 클래스도 위와 같은 이중 연결 리스트를 내부적으로 구현한 것입니다.
또한, LinkedList 클래스 역시 List 인터페이스를 구현하므로, ArrayList 클래스와 사용할 수 있는 메소드가 거의 같습니다.
다음 예제는 여러 LinkedList 메소드를 이용하여 리스트를 생성하고 조작하는 예제입니다.
예제
LinkedList<String> lnkList = new LinkedList<String>();
// add() 메소드를 이용한 요소의 저장
lnkList.add("넷");
lnkList.add("둘");
lnkList.add("셋");
lnkList.add("하나");
// for 문과 get() 메소드를 이용한 요소의 출력
for (int i = 0; i < lnkList.size(); i++) {
System.out.print(lnkList.get(i) + " ");
}
// remove() 메소드를 이용한 요소의 제거
lnkList.remove(1);
// Enhanced for 문과 get() 메소드를 이용한 요소의 출력
for (String e : lnkList) {
System.out.print(e + " ");
}
// set() 메소드를 이용한 요소의 변경
lnkList.set(2, "둘");
for (String e : lnkList) {
System.out.print(e + " ");
}
// size() 메소드를 이용한 요소의 총 개수
System.out.println("리스트의 크기 : " + lnkList.size());
위의 예제를 살펴보면 앞선 예제와 연결 리스트를 생성하는 한 줄의 코드만이 다른 것을 확인할 수 있습니다.
이처럼 ArrayList와 LinkedList의 차이는 사용 방법이 아닌, 내부적으로 요소를 저장하는 방법에 있습니다.
Vector<E> 클래스
Vector 클래스는 JDK 1.0부터 사용해 온 ArrayList 클래스와 같은 동작을 수행하는 클래스입니다.
현재의 Vector 클래스는 ArrayList 클래스와 마찬가지로 List 인터페이스를 상속받습니다.
따라서 Vector 클래스에서 사용할 수 있는 메소드는 ArrayList 클래스에서 사용할 수 있는 메소드와 거의 같습니다.
하지만 현재에는 기존 코드와의 호환성을 위해서만 남아있으므로, Vector 클래스보다는 ArrayList 클래스를 사용하는 것이 좋습니다.
List 인터페이스 메소드
List 인터페이스는 Collection 인터페이스를 상속받으므로, Collection 인터페이스에서 정의한 메소드도 모두 사용할 수 있습니다.
List 인터페이스에서 제공하는 주요 메소드는 다음과 같습니다.
|
메소드 |
설명 |
|
boolean add(E e) |
해당 리스트(list)에 전달된 요소를 추가함. (선택적 기능) |
|
void add(int index, E e) |
해당 리스트의 특정 위치에 전달된 요소를 추가함. (선택적 기능) |
|
void clear() |
해당 리스트의 모든 요소를 제거함. (선택적 기능) |
|
boolean contains(Object o) |
해당 리스트가 전달된 객체를 포함하고 있는지를 확인함. |
|
boolean equals(Object o) |
해당 리스트와 전달된 객체가 같은지를 확인함. |
|
E get(int index) |
해당 리스트의 특정 위치에 존재하는 요소를 반환함. |
|
boolean isEmpty() |
해당 리스트가 비어있는지를 확인함. |
|
Iterator<E> iterator() |
해당 리스트의 반복자(iterator)를 반환함. |
|
boolean remove(Object o) |
해당 리스트에서 전달된 객체를 제거함. (선택적 기능) |
|
boolean remove(int index) |
해당 리스트의 특정 위치에 존재하는 요소를 제거함. (선택적 기능) |
|
E set(int index, E e) |
해당 리스트의 특정 위치에 존재하는 요소를 전달받은 객체로 대체함. (선택적 기능) |
|
int size() |
해당 리스트의 요소의 총 개수를 반환함. |
|
Object[] toArray() |
해당 리스트의 모든 요소를 Object 타입의 배열로 반환함. |
Stack<E> 클래스
Stack 클래스는 List 컬렉션 클래스의 Vector 클래스를 상속받아, 전형적인 스택 메모리 구조의 클래스를 제공합니다.
스택 메모리 구조는 선형 메모리 공간에 데이터를 저장하면서 후입선출(LIFO)의 시멘틱을 따르는 자료 구조입니다.
즉, 가장 나중에 저장된(push) 데이터가 가장 먼저 인출(pop)되는 구조입니다.
Stack 클래스는 스택 메모리 구조를 표현하기 위해, Vector 클래스의 메소드를 5개만 상속받아 사용합니다.
|
메소드 |
설명 |
|
boolean empty() |
해당 스택이 비어 있으면 true를, 비어 있지 않으면 false를 반환함. |
|
E peek() |
해당 스택의 제일 상단에 있는(제일 마지막으로 저장된) 요소를 반환함. |
|
E pop() |
해당 스택의 제일 상단에 있는(제일 마지막으로 저장된) 요소를 반환하고, 해당 요소를 스택에서 제거함. |
|
E push(E item) |
해당 스택의 제일 상단에 전달된 요소를 삽입함. |
|
int search(Object o) |
해당 스택에서 전달된 객체가 존재하는 위치의 인덱스를 반환함. 이때 인덱스는 제일 상단에 있는(제일 마지막으로 저장된) 요소의 위치부터 0이 아닌 1부터 시작함. |
더욱 복잡하고 빠른 스택을 구현하고 싶다면 Deque 인터페이스를 구현한 ArrayDeque 클래스를 사용하면 됩니다.
예제
Deque<Integer> st = new ArrayDeque<Integer>();
다음 예제는 여러 Stack 메소드를 이용하여 스택 메모리 구조를 구현한 예제입니다.
예제
Stack<Integer> st = new Stack<Integer>(); // 스택의 생성
//Deque<Integer> st = new ArrayDeque<Integer>();
// push() 메소드를 이용한 요소의 저장
st.push(4);
st.push(2);
st.push(3);
st.push(1);
// peek() 메소드를 이용한 요소의 반환
System.out.println(st.peek());
System.out.println(st);
// pop() 메소드를 이용한 요소의 반환 및 제거
System.out.println(st.pop());
System.out.println(st);
// search() 메소드를 이용한 요소의 위치 검색
System.out.println(st.search(4));
System.out.println(st.search(3));
단, ArrayDeque 클래스는 Stack 클래스와는 달리 search() 메소드는 지원하지 않습니다.
Queue<E> 인터페이스
클래스로 구현된 스택과는 달리 자바에서 큐 메모리 구조는 별도의 인터페이스 형태로 제공됩니다.
이러한 Queue 인터페이스를 상속받는 하위 인터페이스는 다음과 같습니다.
1. Deque<E>
2. BlockingDeque<E>
3. BlockingQueue<E>
4. TransferQueue<E>
따라서 Queue 인터페이스를 직간접적으로 구현한 클래스는 상당히 많습니다.
그중에서도 Deque 인터페이스를 구현한 LinkedList 클래스가 큐 메모리 구조를 구현하는 데 가장 많이 사용됩니다.
큐 메모리 구조는 선형 메모리 공간에 데이터를 저장하면서 선입선출(FIFO)의 시멘틱을 따르는 자료 구조입니다.
즉, 가장 먼저 저장된(push) 데이터가 가장 먼저 인출(pop)되는 구조입니다.
Queue 인터페이스는 큐 메모리 구조를 표현하기 위해, 다음과 같은 Collection 인터페이스 메소드만을 상속받아 사용합니다.
|
메소드 |
설명 |
|
boolean add(E e) |
해당 큐의 맨 뒤에 전달된 요소를 삽입함. 만약 삽입에 성공하면 true를 반환하고, 큐에 여유 공간이 없어 삽입에 실패하면 IllegalStateException을 발생시킴. |
|
E element() |
해당 큐의 맨 앞에 있는(제일 먼저 저장된) 요소를 반환함. |
|
boolean offer(E e) |
해당 큐의 맨 뒤에 전달된 요소를 삽입함. |
|
E peek() |
해당 큐의 맨 앞에 있는(제일 먼저 저장된) 요소를 반환함. 만약 큐가 비어있으면 null을 반환함. |
|
E poll() |
해당 큐의 맨 앞에 있는(제일 먼저 저장된) 요소를 반환하고, 해당 요소를 큐에서 제거함. 만약 큐가 비어있으면 null을 반환함. |
|
E remove() |
해당 큐의 맨 앞에 있는(제일 먼저 저장된) 요소를 제거함. |
더욱 복잡하고 빠른 큐를 구현하고 싶다면 Deque 인터페이스를 구현한 ArrayDeque 클래스를 사용하면 됩니다.
예제
Deque<Integer> qu = new ArrayDeque<Integer>();
다음 예제는 여러 LinkedList 메소드를 이용하여 큐 메모리 구조를 구현한 예제입니다.
예제
LinkedList<String> qu = new LinkedList<String>(); // 큐의 생성
//Deque<String> qu = new ArrayDeque<String>();
// add() 메소드를 이용한 요소의 저장
qu.add("넷");
qu.add("둘");
qu.add("셋");
qu.add("하나");
// peek() 메소드를 이용한 요소의 반환
System.out.println(qu.peek());
System.out.println(qu);
// poll() 메소드를 이용한 요소의 반환 및 제거
System.out.println(qu.poll());
System.out.println(qu);
// remove() 메소드를 이용한 요소의 제거
qu.remove("하나");
System.out.println(qu);
Java SE 6부터 지원되는 ArrayDeque 클래스는 스택과 큐 메모리 구조를 모두 구현하는데 가장 적합한 클래스입니다.
Set 컬렉션 클래스
Set 인터페이스를 구현한 모든 Set 컬렉션 클래스는 다음과 같은 특징을 가집니다.
1. 요소의 저장 순서를 유지하지 않습니다.
2. 같은 요소의 중복 저장을 허용하지 않습니다.
대표적인 Set 컬렉션 클래스에 속하는 클래스는 다음과 같습니다.
1. HashSet<E>
2. TreeSet<E>
HashSet<E> 클래스
HashSet 클래스는 Set 컬렉션 클래스에서 가장 많이 사용되는 클래스 중 하나입니다.
JDK 1.2부터 제공된 HashSet 클래스는 해시 알고리즘(hash algorithm)을 사용하여 검색 속도가 매우 빠릅니다.
이러한 HashSet 클래스는 내부적으로 HashMap 인스턴스를 이용하여 요소를 저장합니다.
HashSet 클래스는 Set 인터페이스를 구현하므로, 요소를 순서에 상관없이 저장하고 중복된 값은 저장하지 않습니다.
만약 요소의 저장 순서를 유지해야 한다면 JDK 1.4부터 제공하는 LinkedHashSet 클래스를 사용하면 됩니다.
다음 예제는 여러 HashSet 메소드를 이용하여 집합을 생성하고 조작하는 예제입니다.
예제
HashSet<String> hs01 = new HashSet<String>();
HashSet<String> hs02 = new HashSet<String>();
// add() 메소드를 이용한 요소의 저장
hs01.add("홍길동");
hs01.add("이순신");
System.out.println(hs01.add("임꺽정"));
System.out.println(hs01.add("임꺽정")); // 중복된 요소의 저장
// Enhanced for 문과 get() 메소드를 이용한 요소의 출력
for (String e : hs01) {
System.out.print(e + " ");
}
// add() 메소드를 이용한 요소의 저장
hs02.add("임꺽정");
hs02.add("홍길동");
hs02.add("이순신");
// iterator() 메소드를 이용한 요소의 출력
Iterator<String> iter02 = hs02.iterator();
while (iter02.hasNext()) {
System.out.print(iter02.next() + " ");
}
// size() 메소드를 이용한 요소의 총 개수
System.out.println("집합의 크기 : " + hs02.size());
Collection 인터페이스에서는 Iterator 인터페이스를 구현한 클래스의 인스턴스를 반환하는 iterator() 메소드를 정의하여 각 요소에 접근하도록 하고 있습니다.
위의 예제에서 요소의 저장 순서를 바꿔도 저장되는 순서에는 영향을 미치지 않는 것을 확인할 수 있습니다.
또한, add() 메소드를 사용하여 해당 HashSet에 이미 존재하는 요소를 추가하려고 하면, 해당 요소를 저장하지 않고 false를 반환하는 것을 볼 수 있습니다.
이때 해당 HashSet에 이미 존재하는 요소인지를 파악하기 위해서는 내부적으로 다음과 같은 과정을 거치게 됩니다.
1. 해당 요소에서 hashCode() 메소드를 호출하여 반환된 해시값으로 검색할 범위를 결정합니다.
2. 해당 범위 내의 요소들을 equals() 메소드로 비교합니다.
따라서 HashSet에서 add() 메소드를 사용하여 중복 없이 새로운 요소를 추가하기 위해서는 hashCode()와 equals() 메소드를 상황에 맞게 오버라이딩해야 합니다.
다음 예제는 사용자가 정의한 Animal 클래스의 인스턴스를 HashSet에 저장하기 위해 hashCode()와 equals() 메소드를 오버라이딩한 예제입니다.
예제
class Animal {
String species;
String habitat;
Animal(String species, String habitat) {
this.species = species;
this.habitat = habitat;
}
public int hashCode() { return (species + habitat).hashCode(); }
public boolean equals(Object obj) {
if(obj instanceof Animal) {
Animal temp = (Animal)obj;
return species.equals(temp.species) && habitat.equals(temp.habitat);
} else {
return false;
}
}
}
public class Set02 {
public static void main(String[] args) {
HashSet<Animal> hs = new HashSet<Animal>();
hs.add(new Animal("고양이", "육지"));
hs.add(new Animal("고양이", "육지"));
hs.add(new Animal("고양이", "육지"));
System.out.println(hs.size());
}
}
add() 메소드를 통해 같은 값을 가지는 Animal 인스턴스를 여러 번 저장하지만, size() 메소드를 통해 살펴본 HashSet 요소의 총 개수는 1개만 저장되었음을 확인할 수 있습니다.
해시 알고리즘(hash algorithm)
해시 알고리즘(hash algorithm)이란 해시 함수(hash function)를 사용하여 데이터를 해시 테이블(hash table)에 저장하고, 다시 그것을 검색하는 알고리즘입니다.
자바에서 해시 알고리즘을 이용한 자료 구조는 위의 그림과 같이 배열과 연결 리스트로 구현됩니다.
저장할 데이터의 키값을 해시 함수에 넣어 반환되는 값으로 배열의 인덱스를 구합니다.
그리고서 해당 인덱스에 저장된 연결 리스트에 데이터를 저장하게 됩니다.
예를 들어, 정수형 데이터를 길이가 10인 배열에 저장한다고 한다면 1,000,002를 검색하는 방법은 다음과 같을 수 있습니다.
1,000,002를 10으로 나눈 나머지가 2이므로 배열의 세 번째 요소에 연결된 연결 리스트에서 검색을 시작합니다.
매우 간략화한 예제이지만 이렇게 해시 알고리즘을 이용하면 매우 빠르게 검색 작업을 수행할 수 있습니다.
TreeSet<E> 클래스
TreeSet 클래스는 데이터가 정렬된 상태로 저장되는 이진 검색 트리(binary search tree)의 형태로 요소를 저장합니다.
이진 검색 트리는 데이터를 추가하거나 제거하는 등의 기본 동작 시간이 매우 빠릅니다.
JDK 1.2부터 제공되는 TreeSet 클래스는 NavigableSet 인터페이스를 기존의 이진 검색 트리의 성능을 향상시킨 레드-블랙 트리(Red-Black tree)로 구현합니다.
TreeSet 클래스는 Set 인터페이스를 구현하므로, 요소를 순서에 상관없이 저장하고 중복된 값은 저장하지 않습니다.
다음 예제는 여러 TreeSet 메소드를 이용하여 집합을 생성하고 조작하는 예제입니다.
예제
TreeSet<Integer> ts = new TreeSet<Integer>();
// add() 메소드를 이용한 요소의 저장
ts.add(30);
ts.add(40);
ts.add(20);
ts.add(10);
// Enhanced for 문과 get() 메소드를 이용한 요소의 출력
for (int e : ts) {
System.out.print(e + " ");
}
// remove() 메소드를 이용한 요소의 제거
ts.remove(40);
// iterator() 메소드를 이용한 요소의 출력
Iterator<Integer> iter = ts.iterator();
while (iter.hasNext()) {
System.out.print(iter.next() + " ");
}
// size() 메소드를 이용한 요소의 총 개수
System.out.println("이진 검색 트리의 크기 : " + ts.size());
// subSet() 메소드를 이용한 부분 집합의 출력
① System.out.println(ts.subSet(10, 20));
② System.out.println(ts.subSet(10, true, 20, true));
위의 예제처럼 TreeSet 인스턴스에 저장되는 요소들은 모두 정렬된 상태로 저장됩니다.
또한, 위의 예제에서 사용된 subSet() 메소드는 TreeSet 인스턴스에 저장되는 요소가 모두 정렬된 상태이기에 동작이 가능한 해당 트리의 부분 집합만을 보여주는 메소드입니다.
원형
1. public NavigableSet<E> subSet(E fromElement, E toElement)
2. public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
①번 라인에서 사용된 subSet() 메소드는 첫 번째 매개변수로 전달된 값에 해당하는 요소부터 시작하여 두 번째 매개변수로 전달된 값에 해당하는 요소의 바로 직전 요소까지를 반환합니다.
②번 라인에서 사용된 subSet() 메소드는 두 번째와 네 번째 매개변수로 각각 첫 번째와 세 번째 매개변수로 전달된 값에 해당하는 요소를 포함할 것인지 아닌지를 명시할 수 있습니다.
즉, ②번 라인에서 네 번째 매개변수를 false로 변경하면 20을 포함하지 않게 되므로, ①번 라인과 같은 결과를 출력할 것입니다.
Set 인터페이스 메소드
Set 인터페이스는 Collection 인터페이스를 상속받으므로, Collection 인터페이스에서 정의한 메소드도 모두 사용할 수 있습니다.
Set 인터페이스에서 제공하는 주요 메소드는 다음과 같습니다.
|
메소드 |
설명 |
|
boolean add(E e) |
해당 집합(set)에 전달된 요소를 추가함. (선택적 기능) |
|
void clear() |
해당 집합의 모든 요소를 제거함. (선택적 기능) |
|
boolean contains(Object o) |
해당 집합이 전달된 객체를 포함하고 있는지를 확인함. |
|
boolean equals(Object o) |
해당 집합과 전달된 객체가 같은지를 확인함. |
|
boolean isEmpty() |
해당 집합이 비어있는지를 확인함. |
|
Iterator<E> iterator() |
해당 집합의 반복자(iterator)를 반환함. |
|
boolean remove(Object o) |
해당 집합에서 전달된 객체를 제거함. (선택적 기능) |
|
int size() |
해당 집합의 요소의 총 개수를 반환함. |
|
Object[] toArray() |
해당 집합의 모든 요소를 Object 타입의 배열로 반환함. |
Map 컬렉션 클래스
Map 인터페이스는 Collection 인터페이스와는 다른 저장 방식을 가집니다.
Map 인터페이스를 구현한 Map 컬렉션 클래스들은 키와 값을 하나의 쌍으로 저장하는 방식(key-value 방식)을 사용합니다.
여기서 키(key)란 실질적인 값(value)을 찾기 위한 이름의 역할을 합니다.
Map 인터페이스를 구현한 모든 Map 컬렉션 클래스는 다음과 같은 특징을 가집니다.
1. 요소의 저장 순서를 유지하지 않습니다.
2. 키는 중복을 허용하지 않지만, 값의 중복은 허용합니다.
대표적인 Map 컬렉션 클래스에 속하는 클래스는 다음과 같습니다.
1. HashMap<K, V>
2. Hashtable<K, V>
3. TreeMap<K, V>
HashMap<K, V> 클래스
HashMap 클래스는 Map 컬렉션 클래스에서 가장 많이 사용되는 클래스 중 하나입니다.
JDK 1.2부터 제공된 HashMap 클래스는 해시 알고리즘(hash algorithm)을 사용하여 검색 속도가 매우 빠릅니다.
HashMap 클래스는 Map 인터페이스를 구현하므로, 중복된 키로는 값을 저장할 수 없습니다.
하지만 같은 값을 다른 키로 저장하는 것은 가능합니다.
다음 예제는 여러 HashMap 메소드를 이용하여 맵을 생성하고 조작하는 예제입니다.
예제
HashMap<String, Integer> hm = new HashMap<String, Integer>();
// put() 메소드를 이용한 요소의 저장
hm.put("삼십", 30);
hm.put("십", 10);
hm.put("사십", 40);
hm.put("이십", 20);
// Enhanced for 문과 get() 메소드를 이용한 요소의 출력
System.out.println("맵에 저장된 키들의 집합 : " + hm.keySet());
for (String key : hm.keySet()) {
System.out.println(String.format("키 : %s, 값 : %s", key, hm.get(key)));
}
// remove() 메소드를 이용한 요소의 제거
hm.remove("사십");
// iterator() 메소드와 get() 메소드를 이용한 요소의 출력
Iterator<String> keys = hm.keySet().iterator();
while (keys.hasNext()) {
String key = keys.next();
System.out.println(String.format("키 : %s, 값 : %s", key, hm.get(key)));
}
// replace() 메소드를 이용한 요소의 수정
hm.replace("이십", 200);
for (String key : hm.keySet()) {
System.out.println(String.format("키 : %s, 값 : %s", key, hm.get(key)));
}
// size() 메소드를 이용한 요소의 총 개수
System.out.println("맵의 크기 : " + hm.size());
위의 예제에서 사용된 keySet() 메소드는 해당 맵에 포함된 모든 키 값들을 하나의 집합(Set)으로 반환해 줍니다.
위의 예제에서 사용한 for 문은 JDK 1.5부터 추가된 Enhanced for 문입니다.
이 반복문은 배열과 컬렉션 프레임워크에서 해당 인스턴스에 저장된 모든 요소를 순회해야할 경우에 자주 사용됩니다.
Hashtable<K, V> 클래스
Hashtable 클래스는 JDK 1.0부터 사용해 온 HashMap 클래스와 같은 동작을 하는 클래스입니다.
현재의 Hashtable 클래스는 HashMap 클래스와 마찬가지로 Map 인터페이스를 상속받습니다.
따라서 Hashtable 클래스에서 사용할 수 있는 메소드는 HashMap 클래스에서 사용할 수 있는 메소드와 거의 같습니다.
하지만 현재에는 기존 코드와의 호환성을 위해서만 남아있으므로, Hashtable 클래스보다는 HashMap 클래스를 사용하는 것이 좋습니다.
TreeMap<K, V> 클래스
TreeMap 클래스는 키와 값을 한 쌍으로 하는 데이터를 이진 검색 트리(binary search tree)의 형태로 저장합니다.
이진 검색 트리는 데이터를 추가하거나 제거하는 등의 기본 동작 시간이 매우 빠릅니다.
JDK 1.2부터 제공된 TreeMap 클래스는 NavigableMap 인터페이스를 기존의 이진 검색 트리의 성능을 향상시킨 레드-블랙 트리(Red-Black tree)로 구현합니다.
TreeMap 클래스는 Map 인터페이스를 구현하므로, 중복된 키로는 값을 저장할 수 없습니다.
하지만 같은 값을 다른 키로 저장하는 것은 가능합니다.
다음 예제는 여러 TreeMap 메소드를 이용하여 맵을 생성하고 조작하는 예제입니다.
예제
TreeMap<Integer, String> tm = new TreeMap<Integer, String>();
// put() 메소드를 이용한 요소의 저장
tm.put(30, "삼십");
tm.put(10, "십");
tm.put(40, "사십");
tm.put(20, "이십");
// Enhanced for 문과 get() 메소드를 이용한 요소의 출력
System.out.println("맵에 저장된 키들의 집합 : " + tm.keySet());
for (Integer key : tm.keySet()) {
System.out.println(String.format("키 : %s, 값 : %s", key, tm.get(key)));
}
// remove() 메소드를 이용한 요소의 제거
tm.remove(40);
// iterator() 메소드와 get() 메소드를 이용한 요소의 출력
Iterator<Integer> keys = tm.keySet().iterator();
while (keys.hasNext()) {
Integer key = keys.next();
System.out.println(String.format("키 : %s, 값 : %s", key, tm.get(key)));
}
// replace() 메소드를 이용한 요소의 수정
tm.replace(20, "twenty");
for (Integer key : tm.keySet()) {
System.out.println(String.format("키 : %s, 값 : %s", key, tm.get(key)));
}
// size() 메소드를 이용한 요소의 총 개수
System.out.println("맵의 크기 : " + tm.size());
HashMap<K, V> 메소드
HashMap<K, V> 클래스에서 제공하는 주요 메소드는 다음과 같습니다.
|
메소드 |
설명 |
|
void clear() |
해당 맵(map)의 모든 매핑(mapping)을 제거함. |
|
boolean containsKey(Object key) |
해당 맵이 전달된 키를 포함하고 있는지를 확인함. |
|
boolean containsValue(Object value) |
해당 맵이 전달된 값에 해당하는 하나 이상의 키를 포함하고 있는지를 확인함. |
|
V get(Object key) |
해당 맵에서 전달된 키에 대응하는 값을 반환함. 만약 해당 맵이 전달된 키를 포함한 매핑을 포함하고 있지 않으면 null을 반환함. |
|
boolean isEmpty() |
해당 맵이 비어있는지를 확인함. |
|
Set<K> keySet() |
해당 맵에 포함되어 있는 모든 키로 만들어진 Set 객체를 반환함. |
|
V put(K key, V value) |
해당 맵에 전달된 키에 대응하는 값으로 특정 값을 매핑함. |
|
V remove(Object key) |
해당 맵에서 전달된 키에 대응하는 매핑을 제거함. |
|
boolean remove(Object key, Object value) |
해당 맵에서 특정 값에 대응하는 특정 키의 매핑을 제거함. |
|
V replace(K key, V value) |
해당 맵에서 전달된 키에 대응하는 값을 특정 값으로 대체함. |
|
boolean replace(K key, V oldValue, V newValue) |
해당 맵에서 특정 값에 대응하는 전달된 키의 값을 새로운 값으로 대체함. |
|
int size() |
해당 맵의 매핑의 총 개수를 반환함. |
자바 공식 문서에서는 키와 값으로 구성되는 데이터를 매핑(mapping) 또는 엔트리(entry)라고 기술하고 있습니다.
TreeMap<K, V> 메소드
TreeMap<K, V> 클래스에서 제공하는 주요 메소드는 다음과 같습니다.
|
메소드 |
설명 |
|
Map.Entry<K, V> ceilingEntry(K key) |
해당 맵에서 전달된 키와 같거나, 전달된 키보다 큰 키 중에서 가장 작은 키와 그에 대응하는 값의 엔트리를 반환함. 만약 해당하는 키가 없으면 null을 반환함. |
|
K ceilingKey(K key) |
해당 맵에서 전달된 키와 같거나, 전달된 키보다 큰 키 중에서 가장 작은 키를 반환함. 만약 해당하는 키가 없으면 null을 반환함. |
|
void clear() |
해당 맵(map)의 모든 매핑(mapping)을 제거함. |
|
boolean containsKey(Object key) |
해당 맵이 전달된 키를 포함하고 있는지를 확인함. |
|
boolean containsValue(Object value) |
해당 맵이 전달된 값에 해당하는 하나 이상의 키를 포함하고 있는지를 확인함. |
|
NavigableMap<K, V> descendingMap() |
해당 맵에 포함된 모든 매핑을 역순으로 반환함. |
|
Set<Map.Entry<K, V>> entrySet() |
해당 맵에 포함된 모든 매핑을 Set 객체로 반환함. |
|
Map.Entry<K, V> firstEntry() |
해당 맵에서 현재 가장 작은(첫 번째) 키와 그에 대응하는 값의 엔트리를 반환함. |
|
K firstKey() |
해당 맵에서 현재 가장 작은(첫 번째) 키를 반환함. |
|
Map.Entry<K, V> floorEntry(K key) |
해당 맵에서 전달된 키와 같거나, 전달된 키보다 작은 키 중에서 가장 큰 키와 그에 대응하는 값의 엔트리를 반환함. 만약 해당하는 키가 없으면 null을 반환함. |
|
K floorKey(K key) |
해당 맵에서 전달된 키와 같거나, 전달된 키보다 작은 키 중에서 가장 큰 키를 반환함. 만약 해당하는 키가 없으면 null을 반환함. |
|
V get(Object key) |
해당 맵에서 전달된 키에 대응하는 값을 반환함. 만약 해당 맵이 전달된 키를 포함한 매핑을 포함하고 있지 않으면 null을 반환함. |
|
SortedMap<K, V> headMap(K toKey) |
해당 맵에서 전달된 키보다 작은 키로 구성된 부분만을 반환함. |
|
Map.Entry<K, V> higherEntry(K key) |
해당 맵에서 전달된 키보다 작은 키 중에서 가장 큰 키와 그에 대응하는 값의 엔트리를 반환함. 만약 해당하는 키가 없으면 null을 반환함. |
|
K higherKey(K key) |
해당 맵에서 전달된 키보다 작은 키 중에서 가장 큰 키를 반환함. 만약 해당하는 키가 없으면 null을 반환함. |
|
Set<K> keySet() |
해당 맵에 포함되어 있는 모든 키로 만들어진 Set 객체를 반환함. |
|
Map.Entry<K, V> lastEntry() |
해당 맵에서 현재 가장 큰(마지막) 키와 그에 대응하는 값의 엔트리를 반환함. |
|
K lastKey() |
해당 맵에서 현재 가장 큰(마지막) 키를 반환함. |
|
Map.Entry<K, V> lowerEntry(K key) |
해당 맵에서 전달된 키보다 큰 키 중에서 가장 작은 키와 그에 대응하는 값의 엔트리를 반환함. 만약 해당하는 키가 없으면 null을 반환함. |
|
K lowerKey(K key) |
해당 맵에서 전달된 키보다 큰 키 중에서 가장 작은 키를 반환함. 만약 해당하는 키가 없으면 null을 반환함. |
|
Map.Entry<K, V> pollFirstEntry() |
해당 맵에서 현재 가장 작은(첫 번째) 키와 그에 대응하는 값의 엔트리를 반환하고, 해당 엔트리를 맵에서 제거함. |
|
Map.Entry<K, V> pollLastEntry() |
해당 맵에서 현재 가장 큰(마지막) 키와 그에 대응하는 값의 엔트리를 반환하고, 해당 엔트리를 맵에서 제거함. |
|
V put(K key, V value) |
해당 맵에 전달된 키에 대응하는 값으로 특정 값을 매핑함. |
|
V remove(Object key) |
해당 맵에서 전달된 키에 대응하는 매핑을 제거함. |
|
boolean remove(K key, V value) |
해당 맵에서 특정 값에 대응하는 특정 키의 매핑을 제거함. |
|
V replace(K key, V value) |
해당 맵에서 전달된 키에 대응하는 값을 특정 값으로 대체함. |
|
boolean replace(K key, V oldValue, V newValue) |
해당 맵에서 특정 값에 대응하는 전달된 키의 값을 새로운 값으로 대체함. |
|
int size() |
해당 맵의 매핑의 총 개수를 반환함. |
|
SortedMap<K, V> subMap(K fromKey, K toKey) |
해당 맵에서 fromKey부터 toKey까지로 구성된 부분만을 반환함. 이때 fromKey는 포함되나, toKey는 포함되지 않음. |
|
SortedMap<K, V> tailMap(K fromKey) |
해당 맵에서 fromKey와 같거나, fromKey보다 큰 키로 구성된 부분만을 반환함. |
Map.Entry 인터페이스는 Map 인터페이스의 내부 인터페이스로 맵에 저장되는 엔트리의 조작을 위한 메소드가 정의되어 있습니다.
Iterator<E> 인터페이스
자바의 컬렉션 프레임워크는 컬렉션에 저장된 요소를 읽어오는 방법을 Iterator 인터페이스로 표준화하고 있습니다.
Collection 인터페이스에서는 Iterator 인터페이스를 구현한 클래스의 인스턴스를 반환하는 iterator() 메소드를 정의하여 각 요소에 접근하도록 하고 있습니다.
따라서 Collection 인터페이스를 상속받는 List와 Set 인터페이스에서도 iterator() 메소드를 사용할 수 있습니다.
다음 예제는 연결 리스트를 반복자(iterator)를 사용하여 순회하는 예제입니다.
예제
LinkedList<Integer> lnkList = new LinkedList<Integer>();
lnkList.add(4);
lnkList.add(2);
lnkList.add(3);
lnkList.add(1);
Iterator<Integer> iter = lnkList.iterator();
while (iter.hasNext()) {
System.out.print(iter.next() + " ");
}
Iterator 인터페이스는 다음과 같은 메소드를 사용하여 컬렉션의 각 요소에 접근할 수 있습니다.
|
메소드 |
설명 |
|
boolean hasNext() |
해당 이터레이션(iteration)이 다음 요소를 가지고 있으면 true를 반환하고, 더 이상 다음 요소를 가지고 있지 않으면 false를 반환함. |
|
E next() |
이터레이션(iteration)의 다음 요소를 반환함. |
|
default void remove() |
해당 반복자로 반환되는 마지막 요소를 현재 컬렉션에서 제거함. (선택적 기능) |
하지만 현재 자바에서는 될 수 있으면 JDK 1.5부터 추가된 Enhanced for 문을 사용하도록 권장하고 있습니다.
Enhanced for 문을 사용하면 같은 성능을 유지하면서도 코드의 명확성을 확보하고 발생할 수 있는 버그를 예방해 줍니다.
하지만 요소의 선택적 제거나 대체 등을 수행하기 위한 경우에는 반복자(iterator)를 사용해야만 합니다.
Enumeration<E> 인터페이스
Enumeration 인터페이스는 JDK 1.0부터 사용해 온 Iterator 인터페이스와 같은 동작을 하는 인터페이스입니다.
Enumeration 인터페이스는 hasMoreElements()와 nextElement() 메소드를 사용하여 Iterator와 같은 작업을 수행합니다.
하지만 현재에는 기존 코드와의 호환성을 위해서만 남아있으므로, Enumeration 인터페이스보다는 Iterator 인터페이스를 사용하는 것이 좋습니다.
ListIterator<E> 인터페이스
ListIterator 인터페이스는 Iterator 인터페이스를 상속받아 여러 기능을 추가한 인터페이스입니다.
Iterator 인터페이스는 컬렉션의 요소에 접근할 때 한 방향으로만 이동할 수 있습니다.
하지만 JDK 1.2부터 제공된 ListIterator 인터페이스는 컬렉션 요소의 대체, 추가 그리고 인덱스 검색 등을 위한 작업에서 양방향으로 이동하는 것을 지원합니다.
단, ListIterator 인터페이스는 List 인터페이스를 구현한 List 컬렉션 클래스에서만 listIterator() 메소드를 통해 사용할 수 있습니다.
다음 예제는 리스트 반복자를 사용하여 리스트의 모든 요소를 각각 순방향과 역방향으로 출력하는 예제입니다.
예제
LinkedList<Integer> lnkList = new LinkedList<Integer>();
lnkList.add(4);
lnkList.add(2);
lnkList.add(3);
lnkList.add(1);
ListIterator<Integer> iter = lnkList.listIterator();
while (iter.hasNext()) {
System.out.print(iter.next() + " ");
}
while (iter.hasPrevious()) {
System.out.print(iter.previous() + " ");
}
ListIterator 인터페이스는 다음과 같은 메소드를 사용하여 컬렉션의 각 요소에 접근할 수 있습니다.
|
메소드 |
설명 |
|
void add(E e) |
해당 리스트(list)에 전달된 요소를 추가함. (선택적 기능) |
|
boolean hasNext() |
이 리스트 반복자가 해당 리스트를 순방향으로 순회할 때 다음 요소를 가지고 있으면 true를 반환하고, 더 이상 다음 요소를 가지고 있지 않으면 false를 반환함. |
|
boolean hasPrevious() |
이 리스트 반복자가 해당 리스트를 역방향으로 순회할 때 다음 요소를 가지고 있으면 true를 반환하고, 더 이상 다음 요소를 가지고 있지 않으면 false를 반환함. |
|
E next() |
리스트의 다음 요소를 반환하고, 커서(cursor)의 위치를 순방향으로 이동시킴. |
|
int nextIndex() |
다음 next() 메소드를 호출하면 반환될 요소의 인덱스를 반환함. |
|
E previous() |
리스트의 이전 요소를 반환하고, 커서(cursor)의 위치를 역방향으로 이동시킴. |
|
int previousIndex() |
다음 previous() 메소드를 호출하면 반환될 요소의 인덱스를 반환함. |
|
void remove() |
next()나 previous() 메소드에 의해 반환된 가장 마지막 요소를 리스트에서 제거함. (선택적 기능) |
|
void set(E e) |
next()나 previous() 메소드에 의해 반환된 가장 마지막 요소를 전달된 객체로 대체함. (선택적 기능) |
Comparable<T> 인터페이스
Comparable 인터페이스는 객체를 정렬하는 데 사용되는 메소드인 compareTo() 메소드를 정의하고 있습니다.
자바에서 같은 타입의 인스턴스를 서로 비교해야만 하는 클래스들은 모두 Comparable 인터페이스를 구현하고 있습니다.
따라서 Boolean을 제외한 래퍼 클래스나 String, Time, Date와 같은 클래스의 인스턴스는 모두 정렬 가능합니다.
이때 기본 정렬 순서는 작은 값에서 큰 값으로 정렬되는 오름차순이 됩니다.
다음 예제는 인스턴스의 비교를 위해 사용자 정의 클래스인 Car 클래스가 Comparable 인터페이스를 구현하는 예제입니다.
예제
class Car implements Comparable<Car> {
private String modelName;
private int modelYear;
private String color;
Car(String mn, int my, String c) {
this.modelName = mn;
this.modelYear = my;
this.color = c;
}
public String getModel() {
return this.modelYear + "식 " + this.modelName + " " + this.color;
}
public int compareTo(Car obj) {
if (this.modelYear == obj.modelYear) {
return 0;
} else if(this.modelYear < obj.modelYear) {
return -1;
} else {
return 1;
}
}
}
public class Comparable01 {
public static void main(String[] args) {
Car car01 = new Car("아반떼", 2016, "노란색");
Car car02 = new Car("소나타", 2010, "흰색");
System.out.println(car01.compareTo(car02));
}
}
Comparable 인터페이스는 다음과 같은 메소드를 사용하여 객체를 정렬합니다.
|
메소드 |
설명 |
|
int compareTo(T o) |
해당 객체와 전달된 객체의 순서를 비교함. |
Comparator<T> 인터페이스
Comparator 인터페이스는 Comparable 인터페이스와 같이 객체를 정렬하는 데 사용되는 인터페이스입니다.
Comparable 인터페이스를 구현한 클래스는 기본적으로 오름차순으로 정렬됩니다.
반면에 Comparator 인터페이스는 내림차순이나 아니면 다른 기준으로 정렬하고 싶을 때 사용할 수 있습니다.
즉, Comparator 인터페이스를 구현하면 오름차순 이외의 기준으로도 정렬할 수 있게 되는 것입니다.
이때 Comparator 인터페이스를 구현한 클래스에서는 compare() 메소드를 재정의하여 사용하게 됩니다.
다음 예제는 요소를 내림차순으로 정렬하여 저장하는 TreeSet 인스턴스를 생성하기 위해 Comparator 인터페이스를 구현하는 예제입니다.
예제
import java.util.*;
class DescendingOrder implements Comparator<Integer> {
public int compare(Integer o1, Integer o2) {
if(o1 instanceof Comparable && o2 instanceof Comparable) {
Integer c1 = (Integer)o1;
Integer c2 = (Integer)o2;
return c2.compareTo(c1);
}
return -1;
}
}
public class Comparable02 {
public static void main(String[] args) {
TreeSet<Integer> ts = new TreeSet<Integer>(new DescendingOrder());
ts.add(30);
ts.add(40);
ts.add(20);
ts.add(10);
Iterator<Integer> iter = ts.iterator();
while(iter.hasNext()) {
System.out.println(iter.next());
}
}
}
Comparator 인터페이스는 다음과 같은 메소드를 사용하여 객체를 정렬합니다.
|
메소드 |
설명 |
|
int compare(T o1, T o2) |
전달된 두 객체의 순서를 비교함. |
|
boolean equals(Object obj) |
해당 comparator와 전달된 객체가 같은지를 확인함. |
|
default Comparator<T> reversed() |
해당 comparator의 역순인 comparator를 반환함. |
'JAVA' 카테고리의 다른 글
| Java 입력/출력 (0) | 2020.07.04 |
|---|---|
| Java 예외처리 (0) | 2020.07.04 |
| Java API제네릭 (0) | 2020.07.04 |
| Java API클래스 (0) | 2020.07.04 |
| Java 다형성 (0) | 2020.07.04 |
댓글