Java - JCF(Java Collection Framework)

jsbak·2020년 9월 14일
컬렉션프레임워크
0

Java

목록 보기
1/3

Java Collection Framework

  • 자바의 컬렉션(모음)객체들을 다루기 위해 제공되는 재사용 가능한 클래스 또는 인터페이스를 통칭하는 표현
  • 객체로 된 데이터를 어러개 담기 위해
  • java.util 패키지에 포함
인터페이스 분류세부분류특징구현 클래스
CollectionList순서를 유지하고 저장 / 중복 저장 가능ArrayList, Vector, LinkedList
Set순서를 유지하지 않고 저장 / 중복 저장 안됨HashSet, TreeSet
Map키와 값으로 구성된 엔트리 저장 / 키는 중복 저장 안됨HashMap, Hashtable, TreeMap, Properties

List 컬렉션

  • 객체를 인덱스로 관리

    • 객체 저장시 인덱스 부여
    • 인덱스를 통한 검색, 삭제 기능 제공

  • 공통 인터페이스 메서드

    기능메소드설명
    객체추가boolean add(E e)주어진 객체를 맨 끝에 추가
    void add(int index, E element)주어진 인덱스에 객체 추가
    set(int index, E element)주어진 인덱스의 객체를 새로운 객체로 바꿈
    객체검색boolean contains(Object o)주어진 객체가 저장되어 있는지 여부
    E get(int index)주어진 인덱스에 저장된 객체가 있는지 확인
    isEmpty()컬렉션이 비어있는지 조사
    int size()저장되어 있는 전체 객체 수를 리턴
    객체삭제void clear()저장된 모든 객체를 삭제
    E remove(int index)주어진 인덱스에 저장된 객체를 삭제
    boolean remove(Object o)주어진 객체를 삭제

ArrayList

  • 객체를 추가하면 내부 배열에 객체가 저장
  • 일반 배열과 달리 제한없이 객체를 추가 가능
List<E> list = new ArrayList<E>();	// E에 지정된 타입의 객체만 저장
List<E> list = new ArrayList<>();	// E에 지정된 타입의 객체만 저장
List list = new ArrayList();	// 모든 타입의 객체를 저장
  • 예시
public class Board {
	private String subject;
	private String content;
	private String writer;
	
	public Board(String subject, String content, String writer) {
		this.subject = subject;
		this.content = content;
		this.writer = writer;
	}

	public String getSubject() { return subject; }
	public void setSubject(String subject) { this.subject = subject; }
	public String getContent() { return content; } 
	public void setContent(String content) { this.content = content; }
	public String getWriter() { return writer; }
	public void setWriter(String writer) { this.writer = writer; }
}



import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
	public static void main(String[] args) {
		List<Board> list = new ArrayList<>();
		
		list.add(new Board("제목1", "내용1", "글쓴이1"));
		list.add(new Board("제목2", "내용2", "글쓴이2"));
		list.add(new Board("제목3", "내용3", "글쓴이3"));
		list.add(new Board("제목4", "내용4", "글쓴이4"));
		list.add(new Board("제목5", "내용5", "글쓴이5"));
		
		int size = list.size();
		System.out.println("총 객체 수: " + size);
		System.out.println();
		
		// 특정 인덱스의 객체 가져오기
		Board board = list.get(2);
		System.out.println(board.getSubject() + "\t" + board.getContent() +
				"\t" + board.getWriter());
		System.out.println();
		
		// 모든 객체를 하나씩 가져오기
		for(int i=0; i<list.size(); i++) {
			Board b = list.get(i);
			System.out.println(b.getSubject() + "\t" + b.getContent() +
					"\t" + b.getWriter());
		}
		System.out.println();
		
		// 객체 삭제
		list.remove(2);
		list.remove(2); // 기존의 3번째 것이 2번째로 와서 제거 가능
		
		// 향상된 for 문으로 모든 객체를 하나씩 가져오기
		for(Board b : list) {
			System.out.println(b.getSubject() + "\t" + b.getContent() +
					"\t" + b.getWriter());
		}
	}
}

Vector

  • ArrayList 와 동일한 내부 구조
  • 동기화된 메소드를 구성되어 있어 멀티 스레드가 동시에 Vector() 메소드를 실행할 수 없다.
    • 멀티 스레드 환경에서는 안전하게 객체를 추가 또는 삭제 가능.
List<E> list = new Vector<E>();	//E에 지정된 타입의 객체만 저장
List<E> list = new Vector<>();	//E에 지정된 타입의 객체만 저장
List list = new Vector();	// 모든 타입의 객체를 저장
  • 예시 
public class VectorExample {
	public static void main(String[] args) {
		List<Board> list = new Vector<>();
		
		Thread threadA = new Thread() {
			@Override
			public void run() {
				// 객체 1000개 추가
				for(int i=1; i<=1000; i++) {
					list.add(new Board("제목"+i, "내용"+i, "글쓴이"+i));
				}
			}
		};
		
		Thread threadB = new Thread() {
			@Override
			public void run() {
				// 객체 1000개 추가
				for(int i=1; i<=1000; i++) {
					list.add(new Board("제목"+i, "내용"+i, "글쓴이"+i));
				}
			}
		};
		
		
		// 작업 스레드 실행
		threadA.start();
		threadB.start();
		
		// 작업 스레드들이 모두 종료될 때까지 메인 스레드를 기다리게 함
		try {
			threadA.join();
			threadB.join();
		} catch (Exception e) {
		}
		
		// 저장된 총 객체 수 얻기
		int size = list.size();
		System.out.println("총 객체 수: " + size);
		System.out.println();
	}
}
----------------------------------------------------
총 객체 수: 2000

LinkedList

  • ArrayList와 사용 방법은 동일하나 내부 구조는 다름
  • 인접 객체를 체인처럼 연결해서 관리
  • 삭제와 삽입이 잦은 경우 ArrayList 보다는 좋은 성능을 발휘
List<E> list = new LinkedList<E>();	//E에 지정된 타입의 객체만 저장
List<E> list = new LinkedList<>();	//E에 지정된 타입의 객체만 저장
List list = new LinkedList();	// 모든 타입의 객체를 저장
  • 예시
public class LinkedListExample {
	public static void main(String[] args) {
		List<String> list1 = new ArrayList<String>();
		
		List<String> list2 = new LinkedList<String>();
		
		long startTime;
		long endTime;
		
		startTime = System.nanoTime();
		for(int i=0; i<10000; i++) {
			list1.add(0, String.valueOf(i));
		}
		endTime = System.nanoTime();
		System.out.printf("%-17s %8d ns \n", "ArrayList 걸린 시간: ", (endTime-startTime));

		startTime = System.nanoTime();
		for(int i=0; i<10000; i++) {
			list2.add(0, String.valueOf(i));
		}
		endTime = System.nanoTime();
		System.out.printf("%-17s %8d ns \n", "LinkedList 걸린 시간: ", (endTime-startTime));
	}
}
-------------------------------------------
ArrayList 걸린 시간:   6095400 ns 
LinkedList 걸린 시간:   1477200 ns

Set 컬렉션

  • List와 달리 저장 순서가 유지되지 않음.
  • 객체 중복 저장 불가
  • 하나의null 만 저장 가능
  • 수학의 집합에 비유될 수 있다.
    • 집합 : 순서와 상관없고 중복이 허용되지 않음.
기능메소드설명
객체추가boolean add(E e)주어진 객체를 성공적으로 저장하면 true를 리턴하고
중복 객체면 false를 리턴
객체검색boolean contains(Object o)주어진 객체가 저장되어 있는지 여부
isEmpty()컬렉션이 비어있는지 조사
Iterator<E> iterator()저장된 객체를 한 번씩 가져오는 반복자 리턴
int size()저장되어 있는 전체 객체 수 리턴
객체삭제void clear()저장된 모든 객체를 삭제
boolean remove(Object o)주어진 객체를 삭제

HashSet

  • 동일 객체를 저장하지 않음.
    • hashCode() 는 같고 equals() 값이 다른 경우만 저장
Set<E> set = new Set<E>();	//E에 지정된 타입의 객체만 저장
Set<E> set = new Set<>();	//E에 지정된 타입의 객체만 저장
Set set = new Set();	// 모든 타입의 객체를 저장
  • 예시
public class HashSetExample {
	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
		
		set.add("Java");
		set.add("JDBC");
		set.add("JSP");
		set.add("Java");
		set.add("String");
		
		int size = set.size();
		System.out.println("총 객체 수: " + size);
	}
}
--------------------------------------  
총 객체 수: 4
  • 이름과 나이가 동일한 경우 Member 객체를 HashSet에 중복 저장하지 않는 예제
public class Member {
	public String name;
	public int age;
	
	public Member(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	// name과 age 값이 같으면 동일한 hashCode가 리턴
	@Override
	public int hashCode() {
		return name.hashCode() + age;
	}
	
	// name과 age 값이 같으면 true가 리턴
	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Member target) 
			return target.name.equals(name) && (target.age == age);
		else return false;
	}
}

  
public class HashSetExample {
	public static void main(String[] args) {
		Set<Member> set = new HashSet<>();
		
  		// 동등 객체 이므로 하나만 저장
		set.add(new Member("홍길동", 30));
		set.add(new Member("홍길동", 30));
		
		System.out.println("총 객체 수 : " + set.size());
	}
}
----------------------------------
총 객체 수 : 1

Set 컬렉션 조회

  • Set 컬렉션은 인덱스로 객체를 검색해서 가져오는 메서드 X
    • 하나씩 반복해서 가져와야한다.
  • 하나씩 반복해서 가져오는 방법
Set<E> set = new HashSet<>();
for(E e : set) {
	...
}
  • Iterator 를 이용하는 방법
Set<E> set = new HashSet<>();
Iterator<E> iterator = set.iterator();
  • iterator의 메소드
리턴타입메소드명설명
booleanhasNext()가져올 객체가 있으면 true를 리턴하고 없으면 false를 리턴
Enext()컬렉션에서 하나의 객체를 가져옴
voidremove()next()로 가져온 객체를 Set 컬렉션에서 제거
while(iterator.hasNext()) {
	E e = iterator.next();
}
  • 예시
public class HashSetExample {
	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
		
		set.add("Java");
		set.add("JDBC");
		set.add("JSP");
		set.add("String");
		
		// 객체를 하나씩 가져와서 처리
		Iterator<String> iterator = set.iterator();
		while(iterator.hasNext()) {
			// 객체를 하나씩 가져오기
			String element = iterator.next();
			System.out.println(element);
			if(element.equals("JSP")) {
				// 가져온 객체를 컬렉션에서 제거
				iterator.remove();
			}
		}
		System.out.println();
		
		// 객체 제거
		set.remove("JDBC");
		
		// 객체를 하나씩 가져와서 처리
		for(String element : set) {
			System.out.println(element);
		}
	}
}
-------------------------------------------
Java
JSP
JDBC
String

Java
String

Map 컬렉션

  • 키와 값으로 구성된 엔트리 객체를 저장
    • 기존에 저장된 키와 동일한 키로 값을 저장하면 기존의 값은 없어지고 새로운 값으로 대치
  • HashMap, Hashtable, LinkedHashMap, Properties, TreeMap 등 존재
  • 공통 인터페이스 메소드
기능메소드설명
객체추가V put(K key, V value)주어진 키와 값을 추가, 저장되면 값을 리턴
객체검색boolean containsKey(Object key)주어진 키가 있는지 여부
boolean containsValue(Object value)주어진 값이 있는지 여부
Set<Map.Entry<K,V>> entrySet()키와 값 쌍으로 구성된 모든 Map.Entry 객체를 Set에 담아서 리턴
V get(Object key)주어진 키의 값을 리턴
boolean isEmpty()컬렉션이 비어있는지 여부
Set<K> keySet()모든 키를 Set 객체에 담아서 리턴
int size()저장된 키의 총 수를 리턴
Collection<V> values()저장된 모든 값 Collection에 담아서 리턴
객체삭제void clear()모든 map.Entry(키와 값)를 삭제
V remove(Object key)주어진 키와 일치하는 Map.Entry 삭제, 삭제가 되면 리턴

HashMap

  • 키로 사용할 객체가 HashCode() 값이 같고 equals() 값이 같으면 동일한 키로 보고 중복 저장하지 않는다.
  • 생성 방법
Map<K, V> map = new HashMap<K, V>();

- 예시
Map<String, Integer> map = new HashMap<>();

- 가능은 하나 거의 사용되지 않음.
Map map = new HashMap();
  • 예시
public class HashMapExample {
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<>();
		
		map.put("신용권", 85);
		map.put("홍길동", 90);
		map.put("동장군", 80);
		map.put("홍길동", 95);	// 키가 같아 값만 저장
		System.out.println("총 Entry 수: " + map.size());
		System.out.println();
		
		// 키로 값 얻기
		String key = "홍길동";
		int value = map.get(key);
		System.out.println(key + ": " + value);
		System.out.println();
		
		//키 Set 컬렉션을 얻고, 반복해서 키와 값 얻기
		Set<String> keySet = map.keySet();
		Iterator<String> keyIterator = keySet.iterator();
		while (keyIterator.hasNext()) {
			String k = keyIterator.next();
			Integer v  = map.get(k);
			System.out.println(k + " : " + v);
		}
		System.out.println();
		
		// 엔트리 Set 컬렉션을 얻고, 반복해서 키와 값을 얻기
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		Iterator<Entry<String, Integer>> entryIterator = entrySet.iterator();
		while(entryIterator.hasNext()) {
			Entry<String, Integer> entry = entryIterator.next();
			String k = entry.getKey();
			Integer v = entry.getValue();
			System.out.println(k + " : " + v);
		}
		System.out.println();
		
		// 키로 엔트리 삭제
		map.remove("홍길동");
		System.out.println("총 Entry 수: " + map.size());
		System.out.println();
	}
}
--------------------------------
총 Entry 수: 3

홍길동: 95

홍길동 : 95
신용권 : 85
동장군 : 80

홍길동 : 95
신용권 : 85
동장군 : 80

총 Entry 수: 2

Hashtable

  • HashMap과 동일한 구조
  • 동기화된 메소드로 구성되어 멀티 스레드가 동시에 처리 불가

Properties

  • Hashtable의 자식 클래스
    • 키와 값을 String 타입으로 제한한 컬렉션
  • .properties인 프로퍼티 파일을 읽을 때 사용
  • 프로퍼티 파일은 키와 값이 = 으로 연결되어 있는 텍스트 파일
- database.properties
driver=oracle.jdbc.OracleDriver
url=jdbc:oracle:thin:@localhost:1521:orcl
username=scott
password=tiger
admin=\uD64D\uAE38\uB3D9
  • 프로퍼티 파일읽는 방법, Properties 객체 생성후 load() 메서드로 프로퍼티 파일의 내용을 메모리로 로드
Properties properties = new Properties();
properties.load(Xxx.class.getResourceAsStream("database.properties"));
  • 예시
public class PropertiesExample {
	public static void main(String[] args) throws IOException {
		Properties properties = new Properties();
		
		properties.load(PropertiesExample.class.getResourceAsStream(
				"database.properties"));
		
		String driver = properties.getProperty("driver");
		String url = properties.getProperty("url");
		String username = properties.getProperty("username");
		String password = properties.getProperty("password");
		String admin = properties.getProperty("admin");
		
		System.out.println("driver : " + driver);
		System.out.println("url : " + url);
		System.out.println("username : " + username);
		System.out.println("password : " + password);
		System.out.println("admin : " + admin);
	}
}
--------------------------------------------
driver : oracle.jdbc.OracleDriver
url : jdbc:oracle:thin:@localhost:1521:orcl
username : scott
password : tiger
admin : 홍길동

LIFO와 FIFO 컬렉션

  • LIFO : Last In First Out - 나중에 넣은 객체가 먼저 빠져나감
    • Stack
  • FIFO : First In First Out - 먼저 넣은 객체가 먼저 빠져나감
    • Queue

Stack

  • 정의
Stack<E> stack = new Stack<>();

  • 주요 메서드

    리턴 타입메소드설명
    Epush(E item)주어진 객체를 스택에 넣는다.
    Epop()스택의 맨 위 객체를 빼낸다.

  • 예시

public class Coin {
	private int value;
	
	public Coin(int value) {
		this.value = value;
	}

	public int getValue() {
		return value;
	}
}


public class StackExample {
	public static void main(String[] args) {
		// Stack 컬렉션 생성
		Stack<Coin> coinBox = new Stack<Coin>();
		
		// 동전 넣기
		coinBox.push(new Coin(100));
		coinBox.push(new Coin(50));
		coinBox.push(new Coin(500));
		coinBox.push(new Coin(10));
		
		// 동전을 하나씩 꺼내기
		while(!coinBox.isEmpty()) { // isEmpty() List 기반
			Coin coin = coinBox.pop();
			System.out.println("꺼내온 동전 : " + coin.getValue() + "원");
		}
	}
}
------------------------------------------
꺼내온 동전 : 10원
꺼내온 동전 : 500원
꺼내온 동전 : 50원
꺼내온 동전 : 100원

Queue

  • Queue 인터페이스를 구현한 대표적인 클래스는 LinkedList
  • 정의
Queue<E> queue = new LinkedList<>();

  • 주요 메서드

    리턴 타입메소드설명
    booleanoffer(E e)주어진 객체를 큐에 넣는다.
    Epoll()큐에서 객체를 빼낸다.
    Epeek()해당 큐의 맨 앞에 있는(제일 먼저 저장된) 요소를 반환함.

만약 큐가 비어있으면 null을 반환

  • 예제
public class Message {
	public String command;
	public String to;
	public Message(String command, String to) {
		super();
		this.command = command;
		this.to = to;
	}
}


public class QueueExample {
	public static void main(String[] args) {
		Queue<Message> messageQueue = new LinkedList<>();
		
		// 메시지 넣기
		messageQueue.offer(new Message("sendMail", "홍길동"));
		messageQueue.offer(new Message("sendSMS", "신용권"));
		messageQueue.offer(new Message("sendKakaotalk", "감자바"));
		
		// 메시지를 하나씩 꺼내어 처리
		while(!messageQueue.isEmpty()) {
			Message message = messageQueue.poll();
			switch(message.command) {
				case "sendMail":
					System.out.println(message.to + "님에게 메일을 보냅니다.");
					break;
				case "sendSMS":
					System.out.println(message.to + "님에게 SMS를 보냅니다.");
					break;
				case "sendKakaotalk":
					System.out.println(message.to + "님에게 카카오톡을 보냅니다.");
					break;
			}
		}
	}
}
------------------------------------
홍길동님에게 메일을 보냅니다.
신용권님에게 SMS를 보냅니다.
감자바님에게 카카오톡을 보냅니다.

수정할 수 없는 컬렉션

  • List,Set,Map 인터페이스의 정적 메서드 of() 이용한 경우
List<E> immutableList = List.of(E... elements);
Set<E> immutableList = Set.of(E... elements);
Map<K,V> immutableList = Map.of( K k1, V v1, K k2, V v2, ...);
  • List,Set,Map 인터페이스의 정적 메서드 copyOf() 이용한 경우
List<E> immutableList = List.copyOf(Collection<E> coll);
Set<E> immutableList = Set.copyOf(Collection<E> coll);
Map<K,V> immutableList = Map.copyOf(Map<K,V> map);
  • 배열로부터 수정할수 없는 컬렉션 생성 - Arrays.asList();
String[] arr = { "A", "B", "C" }
List<String> immutableList = Arrays.asList(arr);

List인터페이스의특징

(1) 순서(인덱스)가 존재하는 데이터의 집합이다.
-> 인덱스를 가지고 원하는 위치에서 꺼내올 수 있다.
(2) 데이터 중복을 허용

List 인터페이스를 구현하고 있는 클래스

Stack, Vector, LinkedList, ArrayList 등

List 정렬

    1. List 정렬에 대하여
      정렬과 관련된 interface는 Comparable과 Comparator 이렇게 두가지가 있다.
    • 보통 나만의 객체 자체에 정렬 기능을 넣기 위해서 Comparable을 구현
    • 정렬 기준을 별도로 구현, Comparator를 구현하여 사용
    • Comparable에소는 compareTo()메서드를 구현해야하고,
      Comparator에서는 Compare()메서드를 구현해야한다.

Comparable 인터페이스

int compareTo(T o) : 현재 객체(this)와 대상객체(o)의 순서를 비교한다.
 ex) a.compareTo(b);
  * 결과값 : 양수(현재객체가 대상객체보다 사전 순서가 느린 경우)
  	     0 (현재객체가 대상객체와 순서 값이 동일한 경우)
            음수(현재객체가 대상객체보다 사전 순서가 빠른 경우)
int  compare(T o1, T o2) : 첫 번째 객체(o1)와 두 번째 객체(o2)의 순서를 비교한다.
 ex) comparte(a, b);
  * 결과값 : 양수(첫 번째 객체가 두번째 객체보다 사전 순서가 느린 경우)
  	     0 (첫 번째 객체가 두번째 객체와 순서 값이 동일한 경우)
            음수(첫번 째 객체가 두번째 객체보다 사전 순서가 빠른 경우)
public class T01_StackQueueTest {
	/**
	 * Stack => 선입후출(FILO)의 자료구조
	 * Queue => 선입선출(FIFO)의 자료구조
	 * 
	 * Stack과 Queue는 LinkedList를 이용하여 사용할 수 있다.
	 */
	public static void main(String[] args) {
		LinkedList<String> stack = new LinkedList<>();
		/**
		 * stack의 명령
		 * 1) 자료 입력 : push(저장할 값)
		 * 2) 자료 출력 : pop() => 자료를 꺼내온 후 꺼내온 자료를 stack에서 삭제한다.
		 */
		stack.push("홍길동");
		stack.push("일지매");
		stack.push("변학도");
		stack.push("강감찬");
		System.out.println("현재 stack값들 : " + stack);
		String data = stack.pop();
		System.out.println("꺼내온 자료 : " + data);
		System.out.println("꺼내온 자료 : " + stack.pop());
		System.out.println("현재 stack값들 : " + stack);
		stack.push("성춘향");
		System.out.println("현재 stack값들 : " + stack);
		System.out.println("꺼내온 자료 : " + stack.pop());	System.out.println("========================================");
		System.out.println();
		/**
		 *  Queue 명령
		 *  1) 자료 입력 : offer(저장할 값)
		 *  2) 자료 출력 : poll() => 자료를 Queue에서 꺼내온 후 꺼내온 자료는 Queue에서 삭제한다.
		 */
		LinkedList<String> queue = new LinkedList<>();
		queue.offer("홍길동");
		queue.offer("일지매");
		queue.offer("변학도");
		queue.offer("강감찬");
		System.out.println("현재 queue의 값 : "+ queue);
		String temp = queue.poll();
		System.out.println("꺼내온 : "+ temp);
		System.out.println("꺼내온 : "+ queue.poll());
		System.out.println("현재 queue의 값 : "+ queue);
		if(queue.offer("성춘향")) {
			System.out.println("신규 등록 자료 : 성춘향");
		}
		System.out.println("현재 queue의 값 : "+ queue);
		System.out.println("꺼내온 자료 : "+ queue.poll());	
	}
}
/**
 * 정렬과 관련된 interface는 Comparable과 Comparator가 존재한다.
 * 
 * - 보통 객체자체에 정렬기능을 넣기위해서는 Comparable을 구현하고,
 * 	  정렬기준을 별도로 구현하고 싶을 때는 Comparator를 구현하여 사용한다.
 * 
 * - Comparable에서는 compareTo() 메서드를 구현해야하고,
 *   Comparator에서는 compare() 메서드를 구현해야 한다.
 */
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("일지매");
		list.add("홍길동");
		list.add("성춘향");
		list.add("변학도");
		list.add("이순신");		
		System.out.println("정렬 전 : " + list);		
		// 정렬은 Collections.sort()메서드를 이용해서 정렬한다.
		// 기본적으로 '오름차순 정렬'을 수행한다.		
		// 정렬방식을 변경하려면 정렬방식을 결정하는 객체를 만들어서 
		// Collections.sort()메서드에 변수로 넘겨주면 된다.
		Collections.sort(list); //오름차순으로 정렬하기
		System.out.println("정렬 후 : " + list);
		Collections.shuffle(list); //데이터를 섞어준다.
		System.out.println("자료 섞기 후 : " + list);		
		// 정렬 방식을 결정하는 객체(정렬자)를 이용하여 정렬하기
		Collections.sort(list, new Desc());
		System.out.println("정렬 후 : " + list);		
	}
}
/**
 * 정렬방식을 결정하는 class는 Comparator라는 인터페이스를 구현해야 한다.
 * 이 Comparator인터페이스의 compare()라는 메서드를 재정의 하여 구현하면 된다.
 */
class Desc implements Comparator<String> {
/**
 * compare()메서드의 변환값을 결정하는 방법
 * => 이 메서드가 양수를 반환하면 두 값의 순서가 바뀐다.(오름차순이 기본)
 *  
 * - 오름차순정렬일 경우...
 * => 앞의 값이 크면 음수, 같으면 0, 앞의 값이 작으면 양수를 반환한다.
 * 
 * - String객체에는 정렬을 위해서 compareTo()메서드가 구현되어 있는데
 * 	 이 메서드의 반환값은 오름차순에 맞게 반환되도록 구현되어있다.
 *   (Wrapper클래스와 Date, File클래스에도 구현되어 있다.)
 */	
	@Override
	public int compare(String str1, String str2) {
		return str1.compareTo(str2) * -1;
		//String객체는 이미 compareTo()메서드가 구현되어 있다.
	}
}
profile
jsbak
끄적끄적 쓰는곳
다음 포스트

고급자바 - JCF(Java Collection Framework) 2, Set 인터페이스

0개의 댓글