Collection API

주8·2023년 1월 26일

Java의 Collection은 객체 그룹을 저장하고 핸들링하기 위한 아키텍처를 제공하는 컬렉션 프레임워크(Collection framework)이다.
- 컬렉션(다수의 객체)을 다루기 위한 표준화된 프로그래밍 방식
- 컬렉션을 쉽고 편리하게 다룰 수 있는 다양한 클래스를 제공
- java.util 패키지에 포함되어 있다.
검색, 정렬, 삽입, 조작, 삭제와 같은 데이터에 대해 수행하는 모든 작업을 처리할 수 있다.
Collection은 object elements들을 그룹화하여 저장한 single object이다.
성능을 높이면서 소프트웨어의 재사용을 높인다.
다양한 인터페이스(Set, List, Queue, Deque)와 클래스(ArrayList, LinkedList, HashSet, HashMap 등)를 제공한다.
Colleciton interface는 collection을 다루는 가장 기본적인 기능을 정의한다.

Collection의 핵심 인터페이스
모든 컬렉션 클래스는 List, Set, Map 인터페이스 중 하나의 인터페이스를 구현하고 있다.

인터페이스	특징
List	순서가 있는 데이터의 집합, 데이터의 중복을 허용한다. (예: 대기자 명단) 구현 클래스: ArrayList, LinkedList, Stack, Vector 등
Set	순서가 없는 데이터의 집합, 데이터의 중복을 허용하지 않는다. (예: 양의 정수 집합, 소수의 집합) 구현 클래스: HashSet, TreeSet 등
Map	키와 값의 한 쌍으로 이루어진 데이터의 집합으로 순서는 없고, 키는 중복을 허용하지 않으며, 값을 중복으로 허용한다. (예: 우편번호, 지역번호(전화번호)) 구현 클래스: HashMap, TreeMap, Properties 등

iterator(반복자) 인터페이스
컬렉션 요소에 접근하는데 사용할 수 있는 메서드를 제공한다. 모든 컬렉션에는 iterator() 메서드를 포함하고 있으며, 이 메서드로 iterator 인스턴스를 반환한다. 이 인터페이스는 모든 컬렉션의 Root 인터페이스이고, Collection interface는 iterable 인터페이스를 구현한다.
iterator<T> iterator(); iterable 인터페이스는 T 타입의 요소에 대한 iterator를 반환하는 하나의 추상 메서드만 선언되어 있다.

Collection 인터페이스

Collection 인터페이스에서 제공하는 주요 메서드

메서드	설명
boolean add(E e)	해당 컬렉션에 전달된 요소를 추가한다.
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 컬렉션 클래스는 아래와 같다.
- ArrayList, LinkedList, Stack, Vector

public class ListExample{
	public static void main(String[] args){
		List list = new ArrayList();
		list.add("one");
		list.add("second");
		list.add("3rd");
		list.add(Integer.valueOf(4));
		list.add(Float.valuof(5.0F));
		list.add("second"); //중복 저장을 허용한다
		list.add(Integer.valueOf(4)); //중복 저장을 허용한다
		System.out.println(list);
	}
}

[결과]
[one, second, 3rd, 4, 5.0, second, 4]

List 인터페이스 주요 메서드

메서드	설명
add()	List에 요소를 추가
addAll()	모든 요소를 다른 List에 추가
get()	List 요소에 접근하는데 이용
set()	List의 요소 변경
remove()	List의 요소를 제거
clear()	List에서 모든 요소를 제거
size()	List의 길이를 반환
toArray()	List를 배열로 반환
contains()	List에 지정된 요소가 포함된 경우 반환
iterator()	List 요소의 순차적 접근용 Iterator 객체를 반환

ArrayList

List인터페이스를 구현하므로, 저장순서가 유지되고 중복을 허용한다. (java 1,2부터 제공)
가장 많이 사용되는 컬렉션 클래스 중 하나이다.
데이터의 저장공간으로 배열을 사용하지만 요소가 추가되더라도 자동으로 수행된다.
배열을 이용하기 때문에 인덱스를 이용해서 배열 요소에 빠르게 접근할 수 있다.
Vector는 자체적을 동기화처리가 되어 있으나 ArrayList는 그렇지 않다.

public class ArrayListEx1 {
	public static void main(String[] args){
		ArrayList<Integer> arrList = new ArrayList<Integer>();
		// add() 메소드를 이용한 요소의 저장
		arrList.add(40);
		arrList.add(20);
		arrList.add(30);
		arrList.add(10);
		// [40, 20, 30, 10]
		System.out.println("1->" + arrList);
		// remove() 메소드를 이용한 요소의 제거
		arrList.remove(1);
		// [40, 30, 10]
		System.out.println("2->" + arrList);
		// Collections.sort() 메소드를 이용한 요소의 정렬
		Collections.sort(arrList);
		// iterator() 메소드와 get() 메소드를 이용한 요소의 출력
		System.out.print(“3->");
		Iterator<Integer> iter = arrList.iterator();
		// 10 30 40 
		while (iter.hasNext()) {
			System.out.print(iter.next() + " ");
		}
		System.out.println();
		// set() 메소드를 이용한 요소의 변경
		arrList.set(0, 20);
		// [20, 30, 40]
		System.out.println("4->" + arrList);
		// size() 메소드를 이용한 요소의 총 개수
		System.out.println("5-> 리스트의 크기 : " + arrList.size());
	}
}

예제

public static void main(String[] args){
	ArrayList list1 = new ArrayList(10);
	list1.add(Integer.valueOf(5));
	list1.add(Integer.valueOf(4));
	list1.add(Integer.valueOf(2));
	list1.add(Integer.valueOf(0));
	list1.add(Integer.valueOf(1));
	list1.add(Integer.valueOf(3));

	ArrayList list2 = new ArrayList(list1.subList(1,4));
	print(list1, list2);

	Collections.sort(list1); //list1과 list2를 정렬한다.
	Collections.sort(list2);
	print(list1, list2);

	System.out.println("list1.containsAll(list2):"+list1.containsAll(list2));

	list2.add("B");
	list2.add("C");
	list2.add(3, "A");
	print(list1, list2);

	list2.set(3, "AA");
	print(list1, list2);

	//list1에서 list2와 겹치는 부분만 남기고 나머지는 삭제한다.
	System.out.println("list1.retainAll(list2):"+ list1.retainAll(list2));
	print(list1, list2);
}

static void print(ArrayList list1, ArrayList list2){
	System.out.println("list1:"+list1);
	System.out.println("list2:"+list2);
	System.out.println();
}

[결과]
list1:[5, 4, 2, 0, 1, 3]
list2:[4, 2, 0]
list1:[0, 1, 2, 3, 4, 5]
list2:[0, 2, 4]
list1.containsAll(list2):true
list1:[0, 1, 2, 3, 4, 5]
list2:[0, 2, 4, A, B, C]
list1:[0, 1, 2, 3, 4, 5]
list2:[0, 2, 4, AA, B, C]
list1.retainAll(list2):true
list1:[0, 2, 4]
list2:[0, 2, 4, AA, B, C]

LinkedList

LinkedList 클래스는 ArrayList 클래스가 배열을 이용하여 요소를 저장함으로써 발생하는 단점을 극복하기 위해 만들어졌으며(Java 1,2부터 제공) 내부적으로 연결 리스트(linked list)를 이용하여 요소를 저장한다.
배열은 저장된 요소가 순차적으로 저장되지만 연결 리스트는 저장된 요소가 비순차적으로 분포되며, 요소들 사이를 링크(link)로 연결하여 구성한다.
다음 요소를 가리키는 참조만을 가지는 연결리스트는 단일 연결 리스트(singly linked list)라고 한다.
단일 연결리스트는 요소의 저장과 삭제 작업이 다음 요소를 가리키는 참조만 변경하면 되므로, 아주 빠르게 처리될 수 있다. 하지만 단일 연결 리스트는 현재 요소에서 이전 요소로 접근하기가 어렵다.
따라서 이전 요소를 가리키는 참조도 가지는 이중 연결 리스트(doubly linked list)가 좀 더 많이 사용되며, LinkedList 클래스도 이중 연결 리스트를 구현한 것이다.

예제

public class LinkedListEx{
	public static void main(String[] args){
		LinkedList<String> lnkList = new LinkedList<String>();
		//add() 메소드를 이용한 요소의 저장
		lnkList.add("넷");
		lnkList.add("둘");
		lnkList.add("셋");
		lnkList.add("하나");
		System.out.println(lnkList);

		// remove() 메소드를 이용한 요소의 제거
		lnkList.remove(1);
		System.out.println(lnkList);

		// get() 메소드로 요소 접근
		String str = lnkList.get(2);
		System.out.println("요소 접근 : " + str);

		// indexOf() 메소드로 요소의 값 index를 반환
		int index = lnkList.indexOf("셋");
		System.out.println("index는 " + index);

		// set() 메소드를 이용한 요소의 변경
		lnkList.set(2, "둘");
		System.out.println(lnkList);
	}
}

[결과]
[넷, 둘, 셋, 하나]
[넷, 셋, 하나]
요소 접근 : 하나
index는 1
[넷, 셋, 둘]

ArrayList vs LinkedList

사용법에는 차이가 없으며, 내부적으로 요소를 처리하는 방법이 다르다.
순차적으로 데이터를 추가/삭제 - ArrayList가 빠르다
비순차적으로 데이터를 추가/삭제 - LinkedList가 빠르다
접근시간(access time) - ArrayList가 빠르다

스택(Stack)

Stack 클래스는 List 컬렉션 클래스의 Vector 클래스를 상속받아 스택 메모리 구조를 제공한다.
LIFO(후입선출: Last In First Out) 구조로 마지막에 저장된(push) 것을 제일 먼저 가져온다(pop).
스택 메모리 구조는 선형 메모리 공간에 데이터를 저장하면서 후입선출(LIFO)의 시멘틱을 따르는 자료구조이다.
Stack 클래스는 스택 메모리 구조를 표현하기 위해, Vector 클래스의 메서드를 5개만 상속받아 사용한다.

메서드	설명
boolean empty()	스택이 비어 있으면 true, 아니면 false를 반환
E peek()	스택의 제일 상단에 있는 (제일 마지막으로 저장된) 요소를 반환
E pop()	스택의 제일 상단에 있는 (제일 마지막으로 저장된) 요소를 반환하고, 해당 요소를 스택에서 제거
E push(E item)	스택의 제일 상단에 전달된 요소를 삽입
int search(Object o)	전달된 객체가 존재하는 위치의 인덱스를 반환. 요소 위치는 1부터 시작

예제

public class StackEx1{
	public static void main(String[] args){
		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()); // 1
		System.out.println(st); // [4, 2, 3, 1]

		// pop() 메소드를 이용한 요소의 반환 및 제거
		System.out.println(st.pop()); // 1
		System.out.println(st); // [4, 2, 3]

		// search() 메소드를 이용한 요소의 위치 검색
		System.out.println(st.search(4)); // 3
		System.out.println(st.search(3)); // 1
	}
}

[결과]
1
[4, 2, 3, 1]
1
[4, 2, 3]
3
1

큐(Queue)

큐 메모리 구조는 별도의 인터페이스로 제공되며 인터페이스를 상속한 하위 인터페이스는 아래와 같다.
- Deque, BlockingDeque, BlockingQueue, TransferQueue
Deque 인터페이스를 구현한 LinkedList 클래스가 큐 메모리 구조를 구현하는데 가장 많이 사용된다.
큐 메모리 구조는 선형 메모리 공간에 데이터를 저장하면서 선입선출(FIFO: First In First Out)의 시멘틱을 따르는 자료 구조이다.
가장 먼저 저장된(push) 데이터가 가장 먼저 인출(pop)되는 구조이다.
Java 6버전부터 지원되는 ArrayDeque 클래스는 스택과 큐 메모리 구조를 모두 구현하는데 가장 적합한 클래스이다.

메서드	설명
boolean add(E e)	큐의 맨 뒤에 전달된 요소를 삽입한다. 성공하면 true를 반환. 큐에 여유공간이 없으면 IllegalStateException이 발생한다.
E element()	큐의 맨 앞에 있는(제일 먼저 저장된) 요소를 반환한다.
boolean offer(E e)	큐의 맨 뒤에 전달된 요소를 삽입한다.
E peek()	큐의 맨 앞에 있는(제일 먼저 저장된) 요소를 반환한다. 큐가 비어있으면 null을 반환한다.
E poll()	큐의 맨 앞에 있는(제일 먼저 저장된) 요소를 반환하고, 해당 요소를 큐에서 제거한다. 만약 큐가 비어있으면 null을 반환한다.
E remove()	큐의 맨 앞에 있는(제일 먼저 저장된) 요소를 제거한다.

예제

public class QueueEx1 {
	public static void main(String args[]) {
		LinkedList<String> qu = new LinkedList<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);
	}
}

[결과]
넷
[넷, 둘, 셋, 하나]
넷
[둘, 셋, 하나]
[둘, 셋]

Set 인터페이스

List 인터페이스는 요소의 저장 순서가 유지되지 않고 같은 요소의 중복 저장을 허용 안 한다.
대표적인 Set 컬렉션 클래스들: HashSet, TreeSet
HashSet은 Set 컬렉션 클래스 중 가장 많이 사용되는 클래스 중 하나이다. (java 1.2부터 제공)
해시 알고리즘을 사용하여 검색 속도가 매우 빠르다.
HashSet 클래스는 내부적으로 HashMap 인스턴스를 이용하여 요소를 저장한다.
요소의 저장 순서를 유지해야 한다면 java 1.4부터 제공되는 LinkedHashSet 클래스를 사용하면 된다.

public class HashSetEx1 {
	public static void main(String args[]) {
		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("임꺽정")); // 중복된 요소의 저장
		System.out.println(hs01);

		// add() 메소드를 이용한 요소의 저장
		hs02.add("임꺽정");
		hs02.add("홍길동");
		hs02.add("이순신");

		// iterator() 메소드를 이용한 요소의 출력
		Iterator<String> iter02 = hs02.iterator();
		while (iter02.hasNext()) {
			System.out.print(iter02.next() + " ");
		}
		System.out.println();

		// size() 메소드를 이용한 요소의 총 개수
		System.out.println("집합의 크기 : " + hs02.size());
	}
}

[결과]
true
false
[홍길동, 이순신, 임꺽정]
홍길동 이순신 임꺽정
집합의 크기 : 3

Tree Set

TreeSet 클래스(java 1.2부터 제공)는 데이터가 정렬된 상태로 저장되는 이진 검색트리(binary search tree)의 형태로 요소를 저장한다.
이진 검색 트리는 데이터를 추가하거나 제거하는 등의 기본 동작 시간이 매우 빠르다.
TreeSet 인스턴스에 저장되는 요소들은 모두 정렬된 상태로 저장된다.
범위 검색과 정렬에 유리한 컬렉션 클래스로 HashSet보다 데이터 추가, 삭제에 시간이 더 걸린다.

public class TreeSetEx1 {
	public static void main(String args[]) {
		TreeSet<Integer> ts = new TreeSet<Integer>();

		// add() 메소드를 이용한 요소의 저장 ts.add(30);
		ts.add(40);
		ts.add(20);
		ts.add(10); System.out.println(ts);

		// remove() 메소드를 이용한 요소의 제거
		ts.remove(40);
		// iterator() 메소드를 이용한 요소의 출력
		Iterator<Integer> iter = ts.iterator();
		while (iter.hasNext()) {
			System.out.print(iter.next() + " "); 
		}
		System.out.println();

		// size() 메소드를 이용한 요소의 총 개수
		System.out.println("이진 검색 트리의 크기 : " + ts.size()); 
	}
}

[결과]
[10, 20, 30, 40]
10 20 30
이진 검색 트리의 크기:3

Iterators

Iterator는 collection의 elements를 차례대로 스캔하여 작업을 처리해야 할 경우에 많이 사용한다.
ListIterator는 List를 forward(next()) 또는 backward(previous())로 스캔할 수 있다.

메서드	설명
hasNext()	element가 남아 있는지 확인하여 있으면 true, 없으면 false를 반환한다.
next()	다음 element를 읽어온다. next()를 호출하기 전에 hasNext()를 호출해서 읽어 올 요소가 있는지 확인하는 것이 안전하다.
remove()	next()로 읽어온 element를 삭제한다. next()를 호출한 다음에 remove()를 호출해야 한다. (선택적)

예제

List list = new ArrayList(10);
list.add(Integer.valueOf(5));
list.add(Integer.valueOf(4));
list.add(INteger.valueOf(2));

Iterator elements = list.iterator();
while(elements.hasNext()){
	System.out.println(element.next());
}

[결과]
5
4
2

Map

Map은 key와 value가 한 쌍의 데이터로 저장되는 collection object이다.
key는 실질적인 값(value)을 찾기 위한 역할을 한다.
Map 인터페이스를 구현한 모든 Map 컬렉션 클래스는 다음과 같은 특징을 가진다.
- 요소의 저장 순서를 유지하지 않는다.
- 키는 중복을 허용하지 않지만, 값의 중복을 허용한다.
대표적인 Map 컬렉션 클래스들은 다음과 같다.
- HashMap, Hashtable, TreeMap

메서드	설명
void clear()	맵의 모든 매핑을 제거한다.
boolean containsKey(Object key)	맵이 전달된 키를 포함하고 있는지 여부를 확인한다.
boolean containsValue(Object key)	맵이 전달된 값에 해당하는 하나 이상의 키를 포함하고 있는지를 확인한다.
get(Object key)	맵에서 전달된 키에 대응하는 값을 반환한다. 없으면 null을 반환한다.
boolean isEmpty()	맵이 비어있는지를 확인한다.
Set<K> keySet()	맵에 포함되어 있는 모든 키 목록을 Set 객체로 반환한다.
put(K key, V value)	맵에 전달된 키에 대응하는 값으로 특정 값을 매핑한다.
remove(Object key)	맵에서 전달된 키에 대응한 매핑을 제거한다.
int size()	맵의 매핑 총 개수를 반환한다.

HashMap

아래 예제처럼 HashMap은 입력된 순서대로 정렬되지 않는다.
HashMap은 동기화를 제공하지 않고 ConcurrentHashMap클래스는 동시성 성능을 개선하여 java 1.5버전부터 제공된다. (이전에는 Hashtable을 사용)
해싱 기법으로 데이터를 저장하여, 데이터가 많아도 검색이 빠르다.
만약 정렬 순서가 중요하다면 LinkedHashMap을 사용하면 된다.

public class MapEx01{
	public static void main(String[] args){
		Map map = new HashMap();
		map.put("name", "홍길동")
		map.put("address", "서울시");
		System.out.println("map : " + map);
	}
}

[결과]
map : {address=서울시, name=홍길동}

public class HashMapEx3 {
	public static void main(String[] args) {
		HashMap<String, Integer> hm = new HashMap<String, Integer>();
		// put() 메소드를 이용한 요소의 저장
		hm.put("삼십", 30);
		hm.put("십", 10);
		hm.put("사십", 40);
		hm.put("이십", 20);

		System.out.println("맵에 저장된 키들의 집합 : " + hm.keySet());
		for (String key : hm.keySet()) {
			System.out.println(String.format(
							"Key : %s, Value : %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(
							"Key : %s, Value : %s", key, hm.get(key)));
		}
		// replace() 메소드를 이용한 요소의 수정
		hm.replace("이십", 200);
		System.out.println(hm);

		// size() 메소드를 이용한 요소의 총 개수
		System.out.println("맵의 크기 : " + hm.size());
	}
}

TreeMap

키와 값을 한 쌍으로 하는 데이터를 이진 검색 트리(binary search tree)의 형태로 저장한다. (java 1.2부터 제공)
이진 검색 트리는 데이터를 추가하거나 제거하는 등의 기본 동작 시간이 빠르다.
NavigableMap 인터페이스를 기존의 이진 검색 트리의 성능을 향상시킨 레드-블랙 트리(Red-Black tree)로 구현한다.
중복된 키를 저장할 수 없으나 같은 값을 다른 키로 저장하는 것은 가능하다.
HashMap보다 데이터 추가, 삭제에 시간이 더 걸리며 이진 검색 트리의 구조로 키와 값의 쌍으로 이루어진 데이터를 저장한다.
Map이 필요할 때 주로 HashMap을 사용하고, 정렬이나 범위검색이 필요한 경우에 TreeMap을 사용하면 된다.

public class TreeMapEx1 {
	public static void main(String[] args) {
		TreeMap<Integer, String> tm =
				new TreeMap<Integer, String>();

		// put() 메소드를 이용한 요소의 저장
		tm.put(30, "삼십");
		tm.put(10, "십");
		tm.put(40, "사십");
		tm.put(20, "이십");
		System.out.println(tm);

		// remove() 메소드를 이용한 요소의 제거
		tm.remove(40);
		System.out.println(tm);

		// replace() 메소드를 이용한 요소의 수정
		tm.replace(20, "twenty");
		System.out.println(tm);
	}
}

[결과]
{10=십, 20=이십, 30=삼십, 40=사십}
{10=십, 20=이십, 30=삼십}
{10=십, 20=twenty, 30=삼십}

Comparable 인터페이스

Java에서 같은 타입의 인스턴스를 서로 비교해야만 하는 클래스들은 모두 Comparable 인터페이스를 구현하고 있다.
compareTo() 메서드: 두 개의 값을 비교하여 int 값을 반환해주는 메서드다.
- 기준 값과 비교대상이 동일한 값일 경우 0
- 기존 값이 비교대상 보다 작은 경우 -1
- 기준 값이 비교대상 보다 큰 경우 1

public class ComparableEx2 {
	public static void main(String argsp[]){
		String a = "ABC";
		String b = "ABC";
		String c = "BCD";
		String d = "ABCDEF";

		// 맨 첫자리부터 차례대로 비교
		// 문자열은 Unicode 값에 근거한다
		System.out.println(a.compareTo(b)); // 0
		// 인자로 전달받은 문자열보다 전에 있는 경우 결과는 음수가 된다
		// A vs B => feff0041-feff0042 = -1
		System.out.println(a.compareTo(c)); // -1
		System.out.println(a.compareTo(d)); // -3
	}
}

[결과]
0
-1
-3

Comparator 인터페이스

Comparator 인터페이스는 Comparable 인터페이스와 같이 객체를 정렬하는데 사용되는 인터페이스다.
Comparable 인터페이스를 구현한 클래스는 기본적으로 오름차순으로 정렬된다.
Comparator 인터페이스는 내림차순이나 아니면 다른 기준으로 정렬하고 싶을 때 사용할 수 있다.
Comparator 인터페이스를 구현한 클래스는 compare() 메서드를 재정의하여 사용하게 된다.

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 ComparatorEx1 {
	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());
		}
	}
}

[결과]
40
30
20
10