자바의 정석 11장: 컬렉션 프레임웍(collections framework)

Back-End/Java

자바의 정석 11장: 컬렉션 프레임웍(collections framework)

챔🐻 2024. 1. 23. 18:38

[ 출처 ]
자바의 정석:
https://product.kyobobook.co.kr/detail/S000001550352
자바의 정석 유튜브:
https://www.youtube.com/playlist?list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp

11-1 컬렉션 프레임워크(collections framework)

컬렉션(collection)

여러 객체(데이터)를 모아 놓은 것을 의미

프레임워크(framework)

표준화, 정형화된 체계적인 프로그래밍 방식

컬렉션 프레임워크(collections framework)

컬렉션(다수의 객체)을 다루기 위한 표준화된 프로그래밍 방식

컬렉션을 쉽고 편리하게 다룰 수 있는 다양한 클래스를 제공
→ 객체(다수의 데이터)를 다룬다? : 저장, 삭제, 검색, 정렬

java.util 패키지에 포함. JDK1.2부터 제공

컬렉션 클래스(collection class)

다수의 데이터를 저장할 수 있는 클래스(예, Vector, ArrayList, HashSet)

11-2 컬렉션 프레임워크의 핵심 인터페이스

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

List : 순서 O, 중복 O

Set : 순서 X, 중복 X

Map : 순서 X, 중복 : 키는 X, 값은 O

11-3 Collection 인터페이스의 메서드

메서드	설명
boolean add(Object o) boolean add(Collection c)	지정된 객체(o) 또는 Collection(c)의 객체들을 Collection에 추가한다.
void clear()	Collection의 모든 객체를 삭제한다.
boolean contains(Object o) boolean containsAll(Collection o)	지정된 객체(o) 또는 Collection의 객체들이 Collection에 포함되어 있는지 확인한다.
boolean equals(Object o)	동일한 Collection인지 비교한다.
int hashCode()	Collection의 hash code를 반환한다.
boolean isEmpty()	Collection이 비어있는지 확인한다.
Iterator iterator()	Collection의 Iterator를 얻어서 반환한다.
boolean remove(Object o)	지정된 객체를 삭제한다.
boolean removeAll(Collection c)	지정된 Collection에 포함된 객체들을 삭제한다.
boolean retainAll(Collection c)	지정된 Collection에 포함된 객체만을 남기고 다른 객체들은 Collection에서 삭제한다. 이 작업으로 인해 Collection에 번화가 있으면 true를 그렇지 않으면 false를 반환한다.
int size()	Collection에 저장된 객체의 개수를 반환한다.
Object[] toArray()	Collection에 저장된 객체를 객체배열(Object[])로 반환한다.
Object[] toArray(Object[] a)	지정된 배열에 Collection의 객체를 저장해서 반환한다.

11-4 List 인터페이스 - 순서 O, 중복 O

Collection 인터페이스로부터 상속받은 것들은 제외

메서드	설명
void add(int index, Object element) boolean addAll(int index, Collection c)	지정된 위치(index)에 객체(element) 또는 컬렉션에 포함된 객체들을 추가한다.
Object get(int index)	지정된 위치(index)에 있는 객체를 반환한다.
int indexOf(Object o)	지정된 객체의 위치(index)를 반환한다.
int lastIndexOf(Object o)	지정된 객체의 위치(index)를 반환한다. (List의 마지막 요소부터 역방향으로 찾는다.)
ListIterator listIterator() ListIterator listIterator(int index)	List의 객체에 접근할 수 있는 ListIterator를 반환한다.
Object remove(int index)	지정된 위치(index)에 있는 객체를 삭제하고 삭제된 객체를 반환한다.
Object set(int index, Object element)	지정된 위치(index)에 있는 객체를 삭제하고 삭제된 객체를 반환한다.
void sort(Comparator c)	지정된 비교자(comparator)로 List를 정렬한다.
List subList(int fromIndex, int toIndex)	지정된 범위(fromIndex부터 toIndex)에 있는 객체를 반환한다.

11-5 Set 인터페이스 - 순서 X, 중복 X

모두 Collection 인터페이스로부터 상속받은 것들이다.

메서드	설명
boolean add(Object o)	지정된 객체(o) 또는 Collection(c)의 객체들을 Collection에 추가한다.
void clear()	Collection의 모든 객체를 삭제한다.
boolean contains(Object o) boolean containsAll(Collection c)	지정된 객체(o) 또는 Collection의 객체들이 Collection에 포함되어 있는지 확인한다.
boolean equals(Object o)	동일한 Collection인지 비교한다.
int hashCode()	Collection의 hash code를 반환한다.
boolean isEmpty()	Collection이 비어있는지 확인한다.
Iterator iterator()	Collection의 Iterator를 얻어서 반환한다.
boolean remove(Object o)	지정된 객체를 삭제한다.
boolean removeAll(Collection c)	지정된 Collection에 포함된 객체들을 삭제한다.
boolean retainAll(Collection c)	지정된 Collection에 포함된 객체만을 남기고 다른 객체들을 Collection에서 삭제한다. 이 작업으로 인해 Collection에 변화가 있으면 true를 그렇지 않으면 false를 반환한다.
int size()	Collection에 저장된 객체의 개수를 반환한다.
Object[] toArray()	Collection에 저장된 객체를 객체배열(Object[])로 반환한다.
Object[] toArray(Object[] a)	지정된 배열에 Collection의 객체를 저장해서 반환한다.

11-5 Map 인터페이스 - 순서 X, 중복(키 X, 값 O)

+) Map이라는 개념은 어떤 두 값을 연결한다는 의미에서 붙여진 이름이다.

메서드	설명
void clear()	Map의 모든 객체를 삭제한다.
boolean containsKey(Object key)	지정된 key 객체와 일치하는 Map의 key 객체가 있는지 확인한다.
boolean contatinsValue(Object value)	지정된 value 객체와 일치하는 Map의 value 객체가 있는지 확인한다.
Set entrySet()	Map에 저장되어 있는 key-value 쌍을 Map.Entry 타입의 객체로 저장한 Set으로 반환한다.
boolean equals(Object o)	동일한 Map인지 비교한다.
Object get(Object key)	지정한 key 객체에 대응하는 value 객체를 찾아서 반환한다.
int hashCode()	해시코드를 반환한다.
boolean isEmpty()	Map이 비어있는지 확인한다.
Set keySet()	Map에 저장된 모든 key 객체를 반환한다.
Object put(Object key, Object value)	Map에 value 객체를 key 객체에 연결(mapping)하여 저장한다.
void putAll(Map t)	지정된 Map의 모든 key-value쌍을 추가한다.
Object remove(Object key)	지정한 key 객체와 일치하는 key-value 객체를 삭제한다.
int size()	Map에 저장된 key-value쌍의 개수를 반환한다.
Collection values()	Map에 저장된 모든 value 객체를 반환한다.

values()에서는 반환타입이 Collection이고, keySet()에서는 반환타입이 Set인 것에 주목하자. Map 인터페이스에서 값(value)은 중복을 허용하기 때문에 Collection 타입으로 반환하고, 키(key)는 중복을 허용하지 않기 때문에 Set 타입으로 반환한다.

11-7 ArrayList

ArrayList는 기존의 Vector를 개선한 것으로 구현원리와 기능적으로 동일
ArrayList와 달리 Vector는 자체적으로 동기화 처리가 되어있다.

List 인터페이스를 구현하므로, 저장순서가 유지되고 중복을 허용한다. (순서 O, 중복 O)

데이터의 저장공간으로 배열을 사용한다.(배열기반)

public class ArrayList extends AbstractList
	implements List, RandomAccess, Cloneable, java.io.Serializable {
		...
	transient Obejct[] elementData; // Obejct 배열, 모든 종류의 객체를 담을 수 있다.
		...
}

11-8 ArrayList의 메서드

메서드	설명
ArrayList()	크기가 0인 ArrayList를 생성
ArrayList(Collection c)	주어진 컬렉션이 저장된 ArrayList를 생성
ArrayList(int initCapacity)	지정된 초기용량을 갖는 ArrayList를 생성
boolean add(int index)	ArrayList의 마지막에 객체를 추가, 성공하면 true
void add(int index, Object element)	지정된 위치(index)에 객체를 저장
boolean addAll(Collection c)	주어진 컬렉션의 모든 객체를 저장한다.
boolean addAll(int index, Collection c)	지정된 위치부터 주어진 컬렉션의 모든 객체를 저장한다.
void clear()	ArrayList를 완전히 비운다.
Obejct clone()	ArrayLlist를 복제한다.
boolean contains(Obejct o)	지정된 객체(o)가 ArrayList에 포함되어 있는지 확인
void ensureCapacity(int minCapacity)	ArrayList의 용량이 최소한 minCapacity가 되도록 한다.
Obejct get(int index)	지정된 위치(index)에 저장된 객체를 반환한다.
int indexOf(Obejct o)	지정된 객체가 저장된 위치를 찾아 반환한다.
boolean isEmpty()	ArrayList가 비어있는지 확인한다.
Iterator iterator()	ArrayList의 Iterator 객체를 반환
int lastIndexOf(Object o)	객체(o)가 저장된 위치를 끝부터 역방향으로 검색해서 번환
ListIterator listIterator(int index)	ArrayList의 지정된 위치부터 시작하는 ListIterator를 반환.
Object remove(int index)	지정된 위치(index)에 있는 객체를 제거한다.
boolean remove(Object o)	지정된 객체를 제거한다.(성공하면 true, 실패하면 false)
boolean removeAll(Collection c)	지정된 컬렉션에 저장된 것과 동일한 객체들을 ArrayList에서 제거한다.
boolean retainAll(Collection c)	ArrayList에 저장된 객체 중에 주어진 컬렉션과 공통된 것들만을 남기고 나머지는 삭제한다.
Object set(int index, Object element)	주어진 객체(element)를 지정된 위치(index)에 반환한다.
int size()	ArrayList에 저장된 객체의 개수를 반환한다. (값 변경)
void sort(Comparator c)	지정된 정렬기준(c)으로 ArrayList를 정렬
List subList(int fromIndex, int toIndex)	fromIndex부터 toIndex사이에 저장된 모든 객체를 반환한다.
Object[] toArray()	ArrayList에 저장된 모든 객체들을 객체배열로 반환한다.
Obejct[] toArray(Object[] a)	ArrayList에 저장된 모든 객체들을 한꺼번에 a에 담아 반환한다.
void trimToSize()	용량을 크기에 맞게 줄인다.(빈 공간을 없앤다.)

ArrayList의 공간이 부족할 경우 새로운 배열을 만들어서 데이터를 복사해주기 때문에 성능이 떨어질 수 있다. 그렇기 때문에 적절한 기본 길이(capacity)를 선언해주는 것이 좋다.

예제 11-1

import java.util.*;

class Ex11_1 {
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args) {
		ArrayList list1 = new ArrayList(10);
		// ArrayList에는 객체만 저장 가능
		// autoboxing에 의해 기본형이 참조형으로 자동 변환
		list1.add(new Integer(5));
		list1.add(new Integer(4));
		list1.add(new Integer(2));
		list1.add(new Integer(0));
		list1.add(new Integer(1));
		list1.add(new Integer(3));

		ArrayList list2 = new ArrayList(list1.subList(1,4)); 
		print(list1, list2);
	
		// Collections : 클래스 / Collection : 인터페이스
		Collections.sort(list1);
		Collections.sort(list2);
		print(list1, list2);

		System.out.println("list1.contatins(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.add(0, "1");
		print(list1, list2);

		// indexOf()는 지정된 객체의 위치(인덱스)를 알려준다.
		System.out.println("index = " + list1.indexOf(1));
		// list1.remove(1); 				 // 인덱스가 1인 객체를 삭제
		list1.remove(new Integer(1)); // 1을 삭제
		print(list1, list2);
		
		print(list1, list2);
		// list1에서 list2와 일치하는 부분만 남기고 나머지는 삭제한다.
		System.out.println("list1.retainAll(list2) : " + list1.retainAll(list2));
		print(list1, list2);

		// list2에서 list1에 포함된 객체들을 삭제한다.
		for (int i = list2.size()-1; i >= 0; i--) {
			// list1에 list2.get(index)가 포함되어있는지 체크
			if (list1.contains(list2.get(i))) {
				list2.remove(i);
			}
		}

		print(list1, list2);
		// for(int i = list2.size(); )

	} // main의 끝

	@SuppressWarnings("rawtypes")
	static void print(ArrayList list1, ArrayList list2) {
		System.out.println("list1:"+list1);
		System.out.println("list2:"+list2);
		System.out.println();		
	}
} // class

질문
11-8 : 지정된 초기용량 확인하는 법? StringBuffer 배울 때 나왔던 버퍼의 크기? 뭐 그런건가
list.contains, list.containsAll의 차이점..

11-10 ArrayList에 저장된 객체의 삭제과정

ArrayList에 저장된 세 번째 데이터(data[2]를 삭제하는 과정. list.remove(2);를 호출

① 삭제할 데이터 아래의 데이터를 한 칸씩 위로 복사에서 삭제할 데이터를 덮어쓴다.

System.arraycopy(data, 3, data, 2, 2)
// data[3]에서 data[2]로 2개의 데이터를 복사하라는 의미이다.

② 데이터가 모두 한 칸씩 이동했으므로 마지막 데이터는 null로 변경한다.

data[size-1] = null;

③ 데이터가 삭제되어 데이터의 개수가 줄었으므로 size의 값을 감소시킨다.

size--;

✓ 마지막 데이터를 삭제하는 경우, ①의 과정(배열의 복사)은 필요없다.

이동과정(①)이 부담이 많이 가는 작업임. 되도록이면 ① 과정이 일어나지 않도록 하는 것이 중요하다.

배열의 장단점

장점 : 배열은 구조가 간단하고 데이터를 읽는 데 걸리는 시간(접근시간, access time)이 짧다.

단점1 : 크기를 변경할 수 없다.

** 실행중에 변경할 수 없다는 뜻

크기를 변경해야 하는 경우 새로운 배열을 생성 후 데이터를 복사해야함
① 더 큰 배열 생성 → ② 데이터 복사 → ③ 참조변경

크기 변경을 피하기 위해 충분히 큰 배열을 생성하면, 메모리가 낭비된다.

단점2 : 비순차적인 데이터의 추가, 삭제에 시간이 많이 걸린다.

데이터를 추가하거나 삭제하기 위해, 다른 데이터를 옮겨야 함.

그러나 순차적인 데이터 추가(끝에 추가)와 삭제(끝부터 삭제)는 빠르다.

** 배열 단점 : ① 크기 변경 X ② 추가 삭제 시간 오래걸림

11-12 LinkedList

배열과 달리 링크드 리스트는 불연속적으로 존재하는 데이터를 연결(link)

변경에 유리하다.

데이터의 삭제 : 단 한 번의 참조변경만으로

데이터의 추가 : 한번의 Node 객체생성과 두 번의 참조변경만으로 가능

3.2 LinkedList - 이중 연결 리스트

링크드 리스트(linked list) - 연결리스트. 단점 : 데이터 접근성이 나쁨

배열은 각 요소가 연속적이기 때문에 빠르게 원하는 요소의 주소를 얻어서 저장된 데이터를 찾을 수 있다.

하지만 링크드 리스트는 비연속적이기 때문에 다음 요소는 찾을 수 있지만 내 다음다음의 요소는 한 번에 찾을 수 없다.

why? 자신의 다음 주소만 가지고 있기 때문 첫 번째 요소는 두 번째 요소가 어디에 있는지만 알지 세 번째 요소가 어디에 있는지는 모른다.

더블리 링크드 리스트(doubly linked list) - 이중 연결리스트, 접근성 향상

linked list의 접근성이 나쁘다는 단점을 개선한 것이 doubly linked list이다.

doubly linked list는 서로 근접한 두 요소를 앞, 뒤로 이동할 수 있게 연결해둔 것이다.

더블리 써큘러 링크드 리스트(doubly circular linked list) - 이중 원형 연결리스트

이중 연결리스트를 더 개선한 것이 이중 원형 연결리스트이다.

마지막 값 null을 활용

마지막 요소의 다음을 맨 앞 주소값을 넣어두고

첫번 째 요소의 이전을 맨 뒤 주소값을 넣어준다.

ex) TV 채널 1채널에서 뒤로가면 999채널로 가는 것과 비슷하다.

+) 자바는 이중 연결리스트로 구현이 되어있다.

3.3 ArrayList vs. LinkedList - 성능 비교

자료구조의 배열기반 VS 연결기반

① 순차적으로 데이터를 추가/삭제 - ArrayList가 빠름

② 비순차적으로 데이터를 추가/삭제 - LinkedList가 빠름

③ 접근시간(access time) - ArrayList가 빠름

예제 11-5

package ch11;

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

public class ArrayListLinkedListTest {
    public static void main(String[] args) {
        ArrayList al = new ArrayList(2000000);
        LinkedList ll = new LinkedList();

        System.out.println("= 순차적으로 추가하기 =");
        System.out.println("ArrayList :"+add1(al));
        System.out.println("LinkedList :"+add1(ll));
        System.out.println();
        System.out.println("= 중간에 추가하기 =");
        System.out.println("ArrayList :"+add2(al));
        System.out.println("LinkedList :"+add2(ll));
        System.out.println();
        System.out.println("= 중간에서 삭제하기 =");
        System.out.println("ArrayList :"+remove2(al));
        System.out.println("LinkedList :"+remove2(ll));
        System.out.println();
        System.out.println("= 순차적으로 삭제하기 =");
        System.out.println("ArrayList :"+remove1(al));
        System.out.println("LinkedList :"+remove1(ll));
    }

    public static long add1(List list) {
        long start = System.currentTimeMillis();
        for(int i=0; i<1000000;i++) list.add(i+"");
        long end = System.currentTimeMillis();
        return end - start;
    }

    public static long         add2(List list) {
        long start = System.currentTimeMillis();
        for(int i=0; i<10000;i++) list.add(500, "X");
        long end = System.currentTimeMillis();
        return end - start;
    }

    public static long remove1(List list) {
        long start = System.currentTimeMillis();
        for(int i=list.size()-1; i >= 0;i--) list.remove(i);
        long end = System.currentTimeMillis();
        return end - start;
    }

    public static long remove2(List list) {
        long start = System.currentTimeMillis();
        for(int i=0; i<10000;i++) list.remove(i);
        long end = System.currentTimeMillis();
        return end - start;
    }
}

💡

인덱스가 n인 데이터의 주소 = 배열의 주소 + n * 데이터 타입의 크기

ArrayList(배열 기반) vs LinkedList(연결 기반) 성능 비교

컬렉션	읽기(접근시간)	추가 / 삭제	비고
ArrayList	빠르다	느리다	순차적인 추가삭제는 더 빠름. 비효율적인 메모리사용(성능 높이려고 배열 크게 잡음)
LinkedList	느리다	빠르다	데이터가 많을수록 접근성이 떨어짐

다루고자 하는 데이터의 개수가 변하지 않는 경우라면, ArrayList

데이터 개수의 변경이 잦다면 LinkedList를 사용하는 것이 더 나은 선택이 될 수 있다.

11-15 스택과 큐(Stack & Queue)

스택(Stack) : LIFO 구조. 마지막에 저장된 것을 제일 먼저 꺼내게 된다.

큐(Queue) : FIFO 구조. 먼저 저장한 것을 제일 먼저 꺼내게 된다.

Stack과 Queue를 구현하기 위해서는 배열과 링크드리스트중 어떤 것을 사용하는 것이 좋을까?

Stack : 배열이 적합하다.
why? 데이터를 순차적으로 추가하고 삭제하기 때문

Queue : 링크드리스트가 적합하다.
why? Queue는 항상 첫 번째로 저장된 데이터를 삭제하므로, ArrayList와 같은 배열기반의 컬렉션 클래스를 사용한다면 데이터를 꺼낼 때마다 빈 공간을 채우기 위해 데이터의 복사가 발생하므로 비효율적이다.

11-16 스택과 큐(Stack & Queue)의 메서드

Stack의 메서드

메서드	설명
boolean empty()	Stack이 비어있는지 알려준다.
Object peek()	Stack의 맨 위에 저장된 객체를 반환. pop()과 달리 Stack에서 객체를 꺼내지는 않음.(비었을 때는 EmptuStackException을 반환)
Object pop()	Stack의 맨 위에 저장된 객체를 꺼낸다.(비었을 때는 EmptyStackException발생)
Object push()	Stack에 객체(item)을 저장한다.
int search(Object o)	Stack에서 주어진 객체(o)를 찾아서 그 위치를 반환. 못찾으면 -1을 반환. (배열과 달리 위치는 0이 아닌 1부터 시작)

Queue의 메서드

메서드	설명
boolean add(Object o)	지정된 객체를 Queue에 추가한다. 성공하면 true를 반환. 저장공간이 부족하면 IllegalStateException 발생
Object remove()	Queue에서 객체를 꺼내 반환. 비어있으면 NoSuchElementException 발생
Object element()	삭제없이 요소를 읽어온다. peek과 달리 Queue가 비었을 때 NoSuchElementException 발생
boolean offer(Object o)	Queue에 객체를 저장. 성공하면 true. 실패하면 false를 반환.
Object poll()	Queue에서 객체를 꺼내서 반환. 비어있으면 null을 반환
Object peek()	삭제없이 요소를 읽어온다. Queue가 비어있으면 null을 반환

11-18 인터페이스를 구현한 클래스 찾기

All Known Implemention Classes : Queue 인터페이스를 구현한 클래스

Queue 인터페이스에 정의된 기능을 사용하고 싶다면, ‘All Known Implemention Classes’에 적혀있는 클래스들 중에서 적당한 것을 골라 아래와 같은 식으로 객체를 생성해서 사용하면 된다.

Queue g = new LinkedList();
//LinkedList g = new LinkedList();
g.offer("0");

예제 11-2

Stack st = new Stack();
Queue q = new LinkedList(); // Queue 인터페이스를 구현한 클래스인 LinkedList를 사용

st.push("0");
st.push("1");
st.push("2");

q.offer("0");
q.offer("1");
q.offer("2");

System.out.println("= Stack =");

while (!st.empty()) {
	System.out.println(st.pop()); // 스택에서 요소 하나를 꺼내 출력

}

System.out.println("= Queue =");

while (!q.isEmpty()) {
	System.out.println(q.poll()); // 큐에서 요소 하나를 꺼내 출력
}

11-19 스택과 큐(Stack & Queue)의 활용

스택의 활용 예 - 수식계산, 수식괄호검사, 워드프로세서의 undo/redo, 웹브라우저의 뒤로/앞으로

큐의 활용 예 - 최근사용문서, 인쇄작업 대기목록, 버퍼(buffer)

Stack 활용 예제 : 수식괄호 검사

<규칙>

‘(’을 만나면 스택에 넣고

‘)’면 스택에서 ‘(’를 꺼낸다.

<조건체크>

‘)’를 만나서 ‘(’를 꺼내려 할 때 스택이 비어있거나 수식을 검사하고 난 후에도 스택이 비어있지 않으면 괄호가 잘못된 것이다.

‘)’를 만나서 ‘(’를 꺼내려 할 때 스택이 비어있으면 EmptyStackException이 발생하므로 try-catch문을 이용해서 EmptyStackException이 발생하면 괄호가 일치하지 않는다는 메시지를 출력하도록 했다

// 예제 11-3
Stack st = new Stack();
		String expression = "((3+5)*8-2)";

		System.out.println("expresiion : " + expression);

		try {
			for(int i = 0; i < expression.length(); i++) {
				char ch = expression.charAt(i);
	
				if (ch == '(') {
					st.push(ch + "");
				} else if (ch == ')') {
					st.pop();
				}
			}

			if (st.isEmpty()) {
				System.out.println("괄호가 일치합니다.");
			} else {
				System.out.println("괄호가 일치하지 않습니다.");
			}
			
		} catch (EmptyStackException e) {
			System.out.println("괄호가 일치하지 않습니다.");
		}

Stack 활용 예제2 : 웹브라우저 ‘뒤로’, ‘앞으로’

package ch11;

import java.util.Stack;

public class StackEx1 {
    public static Stack back = new Stack();
    public static Stack forward = new Stack();

    public static void main(String[] args) {
        goURL("1. 네이트");
        goURL("2. 야후");
        goURL("3. 네이버");
        goURL("4. 다음");

        printStatus();

        goBack();
        System.out.println("= 뒤로가기 버튼을 누른 후 =");
        printStatus();

        goBack();
        System.out.println("= '뒤로' 버튼을 누른 후 =");
        printStatus();

        goForward();
        System.out.println("= '앞으로' 버튼을 누른 후 =");
        printStatus();

        goURL("codechobo.com");
        System.out.println("= 새로운 주소로 이동 후 =");
        printStatus();
    }

    public static void printStatus() {
        System.out.println("back:"+back);
        System.out.println("forward:"+forward);
        System.out.println("현재화면은 '" + back.peek()+"' 입니다.");
        System.out.println();
    }

    public static void goURL(String url){
        back.push(url);
        if(!forward.empty())
            forward.clear();
    }

    public static void goForward(){
        if(!forward.empty())
            back.push(forward.pop());
    }

    public static void goBack(){
        if(!back.empty())
            forward.push(back.pop());
    }


}

Queue 활용 예제 : 최근 5입력 명령어 보여주기

// 예제 11-4
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {
	static Queue q = new LinkedList();
	static final int MAX_SIZE = 5; // Queue에 최대 5개까지만 저장되도록 한다.

	public static void main(String[] args) {
		System.out.println("help를 입력하면 도움말을 볼 수 있습니다.");

		while(true) {
			System.out.print(">>");

			try {
				Scanner s = new Scanner(System.in);
				String input = s.nextLine().trim(); // 앞, 뒤 공백 제거

				if ("".equals(input)) continue;

				if (input.equalsIgnoreCase("q")) {
					System.exit(0);
				} else if (input.equalsIgnoreCase("help")) {
					System.out.println(" help - 도움말을 보여줍니다.");
					System.out.println(" q 또는 Q - 프로그램을 종료합니다.");
					System.out.println(" history - 최근에 입력한 명령어를 "
											+ MAX_SIZE + "개 보여줍니다.");
				} else if (input.equalsIgnoreCase("history")) {
					LinkedList list = (LinkedList) q;

					final int SIZE = list.size();
					for (int i = 0; i < SIZE; i++) {
						System.out.println((i+1) + "." + list.get(i));
					}
				} else {
					save(input);
					System.out.println(input);
				}

			} catch (Exception e) {
				System.out.println("입력 오류입니다.");
			}
		} // while(true)
	} // main()

	public static void save(String input) {
		// queue에 저장한다.
		if(!"".equals(input)) {
			q.offer(input);
		}

		// queue의 최대 크기를 넘으면 제일 처음 입력된 것을 삭제한다.
		if(q.size() > MAX_SIZE) { // size()는 Collection 인터페이스에 정의
			q.remove();
		}
	}
} // end of class

✅ Check Point

for문 돌릴 때 size 미리 선언해줄 것. 선언하지 않으면 for문 돌 때마다 list의 사이즈를 구해오기 때문에 비효율적임

"".equals(input) 👌
input이 null인건 상관없음. 저정도는 equals가 처리를 해준다.
input.equals(””) ❌
→ NPE 발생 가능성 있음

11-22 Iterator, ListIterator, Enumeration

Iterator

컬렉션에 저장된 요소를 접근하는데 사용되는 인터페이스

메서드	설명
boolean hasNext()	읽어 올 요소가 남아있는지 확인한다. 있으면 true, 없으면 false를 반환한다.
Object next()	다음 요소를 읽어온다. next()를 호출하기 전에 hasNext()를 호출해서 읽어올 요소가 있는지 확인하는 것이 안전하다.
void remove()	next()로 읽어온 요소를 삭제한다. next()를 호출한 다음에 remove()를 호출해야한다.(선택적 기능)
void forEachRemaining(Consumer<? super E> action)	컬렉션에 남아있는 요소들에 대해 지정된 작업(action)을 수행한다. 람다식을 사용하는 디폴트 메서드(JDK1.8부터 추가)

컬렉션에 저장된 요소들을 읽어오는 방법을 표준화한 것이다.

Collection 인터페이스

‘Iterator를 구현한 클래스의 인스턴스'를 반환하는 iterator()를 정의하고있다.

List와 Set 인터페이스의 공통점을 뽑아 만든 것

public interface Collection {
		...
	public Iterator iterator();
		...
}

컬렉션에 iterator()를 호출해서 Iterator를 구현한 객체를 얻어서 사용.

Collection list = new ArrayList();     // 다른 컬렉션으로 변경할 때는 이 부분만 고치면 된다.
Iterator it = list.iterator();

while (it.hasNext()) {           // boolean hasNext() 읽어올 요소가 있는지 확인
	System.out.println(it.next()); // Object next() 다음 요소를 읽어옴
}

예제 11-5

// ArrayList list = new ArrayList();
HashSet list = new HashSet();
Collection c = new TreeSet(); // Set은 Collection의 자손

list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(3));
list.add(new Integer(4));
list.add(new Integer(5));

Iterator it = list.iterator();

while (it.hasNext()) {
    System.out.println(it.next());
}

// for (int i = 0; i < list.size(); i++) {
//     System.out.println(list.get(i));
// }

✅ Check Point

다른 컬렉션으로 변경해야 할 때, ArrayList가 가지고 있는 get 메서드를 이용해 코드를 작성하면 HashSet으로 컬렉션을 변경했을 때 코드를 변경해야한다.
하지만, Iterator로 요소를 가져오면 표준화되어있기 때문에 코드의 변경 없이 사용이 가능하다.

다형성을 이용해 참조변수의 type을 Collection으로 변경하면 추후 인스턴스를 다른 컬렉션으로 변경하게 되었을 때 검토를 하지 않아도되는 장점이 있다.(참조변수 클래스에 존재하는 멤버, 메서드만 쓸 수 있기 때문)
→ 결론 : 참조변수의 종류도 잘 결정해야한다.

ArrayList list = new ArrayList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(3));
list.add(new Integer(4));
list.add(new Integer(5));

Iterator it = list.iterator();

while (it.hasNext()) { // 읽어올 요소가 남아있는지 확인한다.
    System.out.println(it.next());
}

// iterator는 1회용이라 다 쓰고나면 다시 얻어와야 한다.
it = list.iterator(); // 새로운 iterator 객체를 얻는다.

while (it.hasNext()) {
    System.out.println(it.next());
}

✅ Check Point

iterator는 일회용이다. 다 쓰고나면 다시 얻어와야 한다.

예제 11-15

package ch11;

import java.util.ArrayList;
import java.util.Iterator;

public class IteratorEx2 {
    public static void main(String[] args) {
        ArrayList original = new ArrayList(10);
        ArrayList copy1    = new ArrayList(10);
        ArrayList copy2    = new ArrayList(10);

        for (int i = 0; i < 10; i++) {
            original.add(i + "");
        }

        Iterator it = original.iterator();

        while (it.hasNext()) {
            copy1.add(it.next());
        }

        System.out.println("= Original에서 copy1로 복사(copy)");
        System.out.println("original : " + original);
        System.out.println("copy1 : " + copy1);
        System.out.println();

        it = original.iterator(); // Iterator는 재사용이 안 되므로, 다시 얻어와야 한다.

        while (it.hasNext()) {
            copy2.add(it.next());
            it.remove(); // next로 읽어온 것을 삭제한다.
        }

        System.out.println("= Original에서 copy2로 이동(move) =");
        System.out.println("original:"+original);
        System.out.println("copy2:"+copy2);
    }
}

예제 11-16

package ch11;

import java.util.Iterator;

public class MyVector2 extends MyVector implements Iterator {
    int cursor = 0;
    int lastRet = -1;

    public MyVector2(int capacity) {
        super(capacity);
    }

    public MyVector2() {
        super(10);
    }

    @Override
    public String toString() {
        String tmp = "";
        Iterator it = this.iterator();

        for (int i = 0; it.hasNext(); i++) {
            if (i != 0) tmp += ", ";
            tmp += it.next(); // tmp += next().toString();
        }

        return "[" + tmp + "]";
    }

    public Iterator iterator() {
        cursor = 0;  // cursor와 lastRet을 초기화한다.
        lastRet = -1;

        return this;
    }

    // TODO
    // size() -1 아닌가..? cursor가 1부터 시작하면 말이 되는데 0부터잖음
    @Override
    public boolean hasNext() {
        return cursor != size(); // cursor(현재위치)와 size가 같지 않으면 true를 반환
    }

    @Override
    public Object next() {
        Object next = get(cursor);
        lastRet = cursor++;
        return next;
    }

    public void remove() {
        // 더이상 삭제할 것이 없으면 IllegalStateException을 발생시킨다.
        if (lastRet == -1) {
            throw new IllegalStateException();
        } else {
            remove(lastRet);
            // TODO 왜지../??
            cursor--;       // 삭제 후에 cursor의 위치를 감소시킨다.
            lastRet = -1;   // lastRet의 값을 초기화시킨다.
        }
    }


}

예제 11-17

package ch11;

import java.util.Iterator;

public class MyVector2Test {
    public static void main(String[] args) {
        MyVector2 v = new MyVector2();
        v.add("0");
        v.add("1");
        v.add("2");
        v.add("3");
        v.add("4");

        System.out.println("삭제 전 : " + v);
        Iterator it = v.iterator();
        it.next();
//        it.remove();
        it.next();
        it.remove();

        System.out.println("삭제 후 : " + v);
    }
}

Enumeration

Iterator의 구버전

→ 기능을 별 다를게 없음 이름만 다른 것

메서드	설명
boolean hasMoreElements()	읽어 올 요소가 남아있는지 확인한다. 있으면 true, 없으면 false를 반환한다. Iterator의 hasNext()와 같다.
Object nextElement()	다음 요소를 읽어온다. nextElement()를 호출하기 전에 hasMoreElements()를 호출해서 읽어올 요소가 있는지 확인하는 것이 안전하다. Iterator의 next()와 같다.

ListIterator

Iterator에 양방향 조회기능을 추가(List를 구현한 경우만 사용가능)

next(), previous() 둘 다 가능

예제 11-1

11-24 Map과 Iterator

Map에는 iterator()가 없다. keySet(), entrySet(), values()를 호출해야한다.

Collection의 자손이 아니기 때문임

Map map = new HashMap();
Iterator it = map.entrySet().iterator(); // entry => k, v(key, value 한 쌍)
// Set set = map.entryset();
// Iterator it = set.iterator();

11-25~29 Arrays

배열을 다루기 편리한 메서드(static)를 제공한다.

1. 배열의 출력 - `toString()`

static String toString(boolean[] a)
static String toString(byte[] a)
static String toString(char[] a)
static String toString(short[] a)
static String toString(int[] a)
static String toString(long[] a)
static String toString(float[] a)
static String toString(double[] a)
static String toString(Object[] a)

2. 배열의 복사 - `copyOf()`, `copyOfRange()`

copyOf() : 배열 전체 복사

copyOfRange() :

int[] arr = {0, 1, 2, 3, 4};
int[] arr2 = Arrays.copyOf(arr, arr.length);  // arr2 = [0, 1, 2, 3, 4]
int[] arr3 = Arrays.copyOf(arr, 3); // arr3 = [0, 1, 2]
int[] arr4 = Arrays.copyOf(arr, 7); // arr4 = [0, 1, 2, 3, 4, 0, 0]
int[] arr5 = Arrays.copyOfRange(arr, 2, 4); // arr5 = [2, 3] <- 4는 불포함 from <= x < to
int[] arr6 = Arrays.copyOfRange(arr, 0, 7); // arr6 = [0, 1, 2, 3, 4, 0, 0, 0]

3. 배열 채우기 - `fill()`, `setAll()`

int[] arr = new int[5];
Arrays.fill(arr, 9);
Arrays.setAll(arr, (i) -> (int)(Math.random() * 5 ) + 1); // arr = [1, 5, 2, 1, 1]

메서드	설명
toString()
copyOf()	배열 전체를 복사해서 반환한다.
copyOfRange()	지정한 범위의 배열을 복사해서 반환한다.
fill()	배열의 모든 요소를 지정된 값으로 채운다.
setAll()	배열을 채우는데 사용할 함수형 인터페이스를 매개변수로 받는다. 람다식이 반환한 임의의 값으로 배열을 채움
sort()	배열을 정렬한다.
binarySearch()	배열에 저장된 요소를 검색할 때 사용. 배열에서 지정된 값이 저장된 위치를(index)를 찾아서 반환한다. (전제조건 : 배열이 정렬된 상태여야함)

4. 배열의 정렬과 검색 - `sort()`, `binaraySearch()`

int[] arr = {3, 2, 0, 1, 4};
int idx = Arrays.binarySearch(arr, 2); // idx=-5 <- 잘못된 결과

Arrays.sort(arr); // 배열 arr을 정렬한다.
System.out.println(Arrays.toString(arr)); // [0, 1, 2, 3, 4]
idx = Arrays.binarySearch(arr, 2);   // idx = 2 <- 올바른결과

+) 순차 탐색과 이진 탐색(binary search)

순차 검색 : 배열의 첫 번째 요소부터 순서대로 하나씩 검색

이진 검색 : 배열의 검색할 범위를 반복적으로 절반씩 줄여가면서 검색

구분	장점	단점
순차 검색	배열 정렬 필요 X	검색속도 느림
이진 검색	검색속도 빠름	배열 정렬 필수

5. 다차원 배열의 출력 - `deepToString()`

toString()은 일차원 배열에만 사용할 수 있다.

deepToString()은 배열의 모든 요소를 재귀적으로 접근해서 문자열을 구성하므로 2차원뿐만 아니라 3차원 이상의 배열에도 동작한다.

int[] arr = {0, 1, 2, 3, 4};
int[][] arr2D = {{11, 22}, {21, 22}};

System.out.println(Arrays.toString(arr));       // [0, 1, 2, 3, 4]
System.out.println(Arrays.deepToString(arr2D)); // [[11, 12], [21,22]]

6. 다차원 배열의 비교 - `deepEquals()`

String[][] str2D = new String[][]{{"aaa", "bbb"}, {"AAA", "BBB"}};
String[][] str2D2 = new String[][]{{"aaa", "bbb"}, {"AAA", "BBB"}};

System.out.println(Arrays.equals(str2D, str2D2));     // false
System.out.println(Arrays.deepEquals(str2D, str2D2)); // true

위와 같이 2차원 String 배열을 equals()로 비교하면 저장된 내용이 같은데도 false를 결과로 얻는다. 다차원 배열은 ‘배열의 배열'이 형태로 구성하기 때문에 equals()로 비교하면, 문자열을 비교하는 것이 아니라 ‘배열에 저장된 배열의 주소’를 비교하게 된다. 서로 다른 배열은 항상 주소가 다르므로 false를 결과로 얻는다.

7. 배열을 List로 변환 - `asList(Object… a)`

asList()는 배열을 List에 담아서 반환한다. 매개변수의 타입이 가변인수라서 배열 생성없이 저장할 요소들만 나열하는 것도 가능하다.

List list = Arrays.asList(new Integer[]{1, 2, 3, 4, 5}); // [1, 2, 3, 4, 5]
List list = Arrays.asList(1, 2, 3, 4, 5);         // [1, 2, 3, 4, 5]
list.add(6); // UnsupportedOperationException 예외 발생(읽기 전용임)

✔️ asList()가 반환한 List의 크기는 변경할 수 없다.

→ 추가, 삭제 불가능, 저장된 내용은 변경 가능

만일 크기를 변경할 수 있는 List가 필요하다면 다음과 같이 하면 된다.

List list = new ArrayList(Arrays.asList(1, 2, 3, 4, 5)); // 새로운 ArrayList 생성, 변경 가능

예제 11-6

package chapter11;

import java.util.*;

class Ex11_6 {
	public static void main(String[] args) {
		int[]	   arr   = {0,1,2,3,4};
		int[][]	arr2D = {{11,12,13}, {21,22,23}};

		System.out.println("arr="+Arrays.toString(arr));
		System.out.println("arr2D="+Arrays.deepToString(arr2D));

		int[] arr2 = Arrays.copyOf(arr, arr.length);
		int[] arr3 = Arrays.copyOf(arr, 3);          
		int[] arr4 = Arrays.copyOf(arr, 7);          
		int[] arr5 = Arrays.copyOfRange(arr, 2, 4);  
		int[] arr6 = Arrays.copyOfRange(arr, 0, 7);  

		System.out.println("arr2="+Arrays.toString(arr2));
		System.out.println("arr3="+Arrays.toString(arr3));
		System.out.println("arr4="+Arrays.toString(arr4));
		System.out.println("arr5="+Arrays.toString(arr5));
		System.out.println("arr6="+Arrays.toString(arr6));
		
		int[] arr7 =  new int[5];
		Arrays.fill(arr7, 9);  // arr=[9,9,9,9,9]
		System.out.println("arr7="+Arrays.toString(arr7));

		Arrays.setAll(arr7, i -> (int)(Math.random()*6)+1);
		System.out.println("arr7="+Arrays.toString(arr7));

		for(int i : arr7) {
			char[] graph = new char[i];
			Arrays.fill(graph, '*');
			System.out.println(new String(graph)+i);
		}

		String[][] str2D  = new String[][]{{"aaa","bbb"},{"AAA","BBB"}};
		String[][] str2D2 = new String[][]{{"aaa","bbb"},{"AAA","BBB"}};

		System.out.println(Arrays.equals(str2D, str2D2));     // false
		System.out.println(Arrays.deepEquals(str2D, str2D2)); // true

		char[] chArr = { 'A', 'D', 'C', 'B', 'E' };

		System.out.println("chArr="+Arrays.toString(chArr));
		System.out.println("index of B ="+Arrays.binarySearch(chArr, 'B'));
		System.out.println("= After sorting =");
		Arrays.sort(chArr);
		System.out.println("chArr="+Arrays.toString(chArr));
		System.out.println("index of B ="+Arrays.binarySearch(chArr, 'B'));
	}
}

11-30 Comparator와 Comparable

객체 정렬에 필요한 메서드(정렬기준 제공)를 정의한 인터페이스
Comparable을 구현한 클래스는 정렬이 가능하다는 것을 의미함.
💡
Comparable 기본 정렬기준을 구현하는데 사용

Comparator 기본 정렬기준 외에 다른 기준으로 정렬하고자할 때 사용
```
public interface Comparator {
	int compare(Object o1, Object o2); // o1, o2 두 객체를 비교
	boolean equals(Obejct obj);        // equals를 오버라이딩하라는 뜻
}

public interface Comparable {
	int compareTo(Object o); // 주어진 객체(o)를 자신과 비교
}
```

compare()과 compareTo()는 두 객체의 비교결과를 반환하도록 작성

같으면 0, 오른쪽이 크면 음수(-), 작으면 양수(+)

public final class Integer extends Number implements Comparable {
	...
	public int compareTo(Integer anotherInteger) {
		int v1 = this.value;
		int v2 = anotherInteger.value;
	
		// 같으면 0, 오른쪽 값이 크면 -1, 작으면 1을 반환
		return (v1 < v2 ? -1 : (v1 == v2 ? 0 : 1));
	}

}

예제 11-7

static void sort(Object[] a) // 객체 배열에 저장된 객체가 구현한 Comparable에 의한 정렬
static void sort(Object[] a, Comparator c) // 지정한 Comparator에 의한 정렬

Arrays.sort()는 배열을 정렬할 때, Comparator를 지정해주지 않으면 저장하는 객체(Comparable을 구현한 클래스의 객체)에 구현된 내용에 따라 결정된다.

소스코드

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        String[] strArr = {"cat", "Dog", "tiger", "lion"};
        System.out.println("strArr = " + Arrays.toString(strArr));

        Arrays.sort(strArr); // String의 Comparable 구현에 의한 정렬
        System.out.println("strArr = " + Arrays.toString(strArr));

        Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER); // 대소문자 구분안함
        System.out.println("strArr = " + Arrays.toString(strArr));

        Arrays.sort(strArr, new Descending());
        System.out.println("strArr = " + Arrays.toString(strArr));

    } // main
}

class Descending implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        if( o1 instanceof Comparable && o2 instanceof Comparable ) { // Comparable로 형변환 가능 여부 체크
            Comparable c1 = (Comparable) o1;
            Comparable c2 = (Comparable) o2;

            return c1.compareTo(c2) * -1; // -1을 곱해서 기본 정렬방식의 역으로 변경한다.
                                          // 또는 c2.compareTo(c1)와 같이 순서를 바꿔도 된다.
        }   

        return -1;
    }
}

11-32 Integer와 Comparable

Arrays.sort()와 같은 메서드의 정렬 알고리즘은 이미 훌륭하게 잘 작성되어 있으므로, 우리가 해야 할 일은 아래와 같이 compareTo()를 구현해서 어떤 비교기준으로 정렬할지만 알려주는 것으로 충분하다.

public final class Integer extends Number implements Comparable {
																					// 기본 정렬 기준(default - 정렬 기준이 없을 때 사용)
		...
	public int compareTo(Object o) {
		return compareTo((Integer)o);
	}
	
	// Arrays.sort()와 같은 메서드가 정렬을 수행하는 과정에서. compareTo()를 호출한다.
	public int compareTo(Integer anotherInteger) {
		int thisVal = this.value;
		int anotherVal = anotherInteger.value;
	
		// 비교하는 값이 크면 -1. 같으면 0, 작으면 1을 반환한다.
		return (thisVal < anotherVal ? -1 : (thisVal == anotherVal ? 0 : 1));

//		// 왼쪽 값이 크면 음수를, 두 값이 같으면 0, 왼쪽 값이 크면 양수를 반환한다.
//		return thisVal - anotherVal; // 내림차순의 경우 반대로 뺄셈하면 된다.
	}
}

💡 간단하게 뺄셈하지 않고 복잡하게 삼항연산자를 쓰는 이유?

삼항연산자가 성능상 유리함(아주 약간)

예제 11-8 : 1~50 사이의 숫자 중에서 25개를 골라서 '5 x 5' 크기의 빙고판을 만든다.

package chapter11;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

// 1~50 사이의 숫자 중에서 25개를 골라서 '5 x 5' 크기의 빙고판을 만드는 예제
public class Ex11_8 {
    public static void main(String[] args) {
        Set set = new HashSet();
        // Set set = LinkedHashSet();
        int[][] board = new int[5][5];

        // 1~50 사이의 랜덤한 숫자를 25개 골라서 Set에 넣어준다.
        for (int i = 0; set.size() < 25; i++) {
            set.add((int)(Math.random() * 50) + 1 + "");
        }

        Iterator it = set.iterator();

        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                board[i][j] = Integer.parseInt((String)it.next());
                System.out.print((board[i][j] < 10 ? "  " : " ") + board[i][j]);
            }
            System.out.println();
        }
        




    }
}

11-34 HashSet - 순서X, 중복X

Set 인터페이스를 구현한 대표적인 컬렉션 클래스

순서를 유지하려면, LinkedHashSet 클래스를 사용하면 된다.

생성자 또는 메서드	설명
HashSet()	HashSet 객체를 생성한다.
HashSet(Collection c)	주어진 컬렉션을 포함하는 HashSet 객체를 생성한다.
HashSet(int initialCapacity)	주어진 값을 초기용량으로하는 HashSet 객체를 생성한다.
HashSet(int initialCapacity, float loadFactor)	초기용량와 load factor를 지정하는 생성자
boolean add(Object o)	새로운 객체를 저장한다.(성공하면 true, 실패하면 false)
boolean addAll(Collection c)	주어진 컬렉션에 저장된 모든 객체들을 추가한다.(합집합)
void clear()	저장된 모든 객체를 삭제한다.
Object clone()	HashSet을 복제해서 반환한다.(얕은 복사)
boolean contains(Object o)	지정된 객체를 포함하고 있는지 알려준다.
boolean containsAll(Collection c)	주어진 컬렉션에 저장된 모든 객체들을 포함하고 있는지 알려준다.
boolean isEmpty()	HashSet이 비어있는지 알려준다.
Iterator iterator()	iterator를 반환한다.
boolean remove(Obejct o)	지정된 객체를 HashSet에서 삭제한다.(성공하면 true, 실패하면 false)
boolean removeAll(Collecton c)	주어진 컬렉션에서 저장된 모든 객체와 동일한 것들을 HashSet에서 모두 삭제한다.(차집합)
boolean retainAll(Collection c)	주어진 컬렉션에 저장된 객체와 동일한 것만 남기고 삭제한다.(교집합)
int size()	저장된 객체의 개수를 반환한다.
Object[] toArray()	저장된 객체들을 객체배열의 형태로 반환한다.
Object[] toArray(Object[] a)	지정된 객체들을 주어진 객체배열(a)에 담는다.

+) load factor는 컬렉션 클래스에 저장공간이 가득 차기 전에 미리 용량을 확보하기 위한 것으로 0.8로 지정하면, 저장공간의 80%가 채워졌을 때 용량이 두 배로 늘어난다. 기본값은 0.75, 즉 75%이다.

예제 11-9

Object[] objArr = {"1",new Integer(1),"2","2","3","3","4","4","4"};
Set set = new HashSet();

for (int i = 0; i < objArr.length; i++) {
    System.out.println(objArr[i] + " = " + set.add(objArr[i]));
}

// HashSet에 저장된 요소들을 출력한다.
System.out.println(set);

// HashSet에 저장된 요소들을 출력한다.(Iterator 이용)
Iterator it = set.iterator();

while (it.hasNext()) { // 읽어올 요소가 있는지 확인
    System.out.println(it.next()); // 다음 요소를 출력한다.
}

결과

<결과>
1=true
1=true
2=true
2=false
3=true
3=false
4=true
4=false
4=false
[1, 1, 2, 3, 4]
1
1
2
3

HashSet은 중복된 값을 저장하지 않는데, 결과를 보면 1이 두 번 출력되었다.

둘 다 ‘1’로 보이기 때문에 구별이 안 되지만, 사실 하나는 String 인스턴스이고 다른 하나는 Integer 인스턴스로 서로 다른 객체이므로 중복으로 간주하지 않는다.

+) 중복을 제거하는 동시에 저장한 순서를 유지하고 싶다면 LinkedHashSet을 사용하면 된다.

예제 11-10 : 로또번호

중복된 값은 저장되지 않는 HashSet의 성질을 이용해서 로또번호를 만드는 예제.

몇 번 실행해보면 같은 숫자가 비슷한 위치에 나온다는 사실을 발견할 수 있다. HashSet은 저장된 순서를 보장하지 않고 자체적인 저장방식에 따라 순서가 결졍되기 때문에 이 경우에는 LinkedHashSet이 더 나은 선택이다.

Set set = new HashSet();
// Set set = new LinkedHashSet();

for (int i = 0; set.size() < 6; i++) {
    int num = (int)(Math.random() * 45) + 1;
    // set.add(new Integer(num));
    set.add(num);
}

System.out.println(set); // set은 정렬불가 why? set은 순서 유지를 안 하기 때문

List list = new LinkedList(set); // LinkedList(Collection c) / 1. set의 모든 요소를 List(LinkedList)에 저장
Collections.sort(list);          // Collections.sort(List list) / 2. list를 정렬
System.out.println(list);        // 3. list를 출력

11-37 HashSet - 예제3

HashSet은 객체를 저장하기 전에 기존에 같은 객체가 있는지 확인한다.
같은 객체가 없으면 저장하고, 있으면 저장하지 않는다.

boolean add(Obejct o)는 기존에 저장된 요소와 같은 것인지 판별하기 위해 추가하려는 요소의equals()와 hashCode()를 호출한다.
그래서 equals()와 hashCode()가 오버라이딩 되어 있어야 한다.

예제 11-11

package chapter11;

import java.util.HashSet;
import java.util.Objects;

public class Ex11_11 {
    public static void main(String[] args) {
        HashSet set = new HashSet();
				/*
         * HashSet은 객체를 저장하기 전에 기존에 같은 객체가 있는지 확인한다.
         * 같은 객체가 없으면 저장하고, 있으면 저장하지 않는다.
         * 
         * boolean add(Object o)는 저장할 객체의 equals()와 hashCode()를 호출해 같은 객체가 있는지 검사함.
         * 그래서 저장하는 객체가 equals()와 hashCode()가 오버라이딩 되어있어야함.
         */
        set.add("abc");
        set.add("abc");
        set.add(new Person("Ann", 21));
        set.add(new Person("Ann", 21));

        System.out.println(set);
    }
}

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return name + ":" + age;
    }

    public boolean equals(Object obj) {
        if(!(obj instanceof Person)) return false;

        Person p = (Person) obj;
        return name.equals(p.name) && age == p.age;
    }

    public int hashCode() {
        return Objects.hash(name, age);
    }
}

예제 11-12

package chapter11;

import java.util.HashSet;
import java.util.Iterator;

public class Ex11_12 {
    public static void main(String[] args) {
        HashSet setA = new HashSet();
        HashSet setB = new HashSet();
        HashSet setHab = new HashSet();
        HashSet setKyo = new HashSet();
        HashSet setCha = new HashSet();

        setA.add("1");
        setA.add("2");
        setA.add("3");
        setA.add("4");
        setA.add("5");

        System.out.println("A = " + setA);

        setB.add("4");
        setB.add("5");
        setB.add("6");
        setB.add("7");
        setB.add("8");

        System.out.println("B = " + setB);

        Iterator it = setB.iterator();
        while (it.hasNext()) {
            Object tmp = it.next();
            if (setA.contains(tmp)) {
                setKyo.add(tmp);
            }
        }

        it = setA.iterator();
        while (it.hasNext()) {
            Object tmp = it.next();
            if(!setB.contains(tmp)) {
                setCha.add(tmp);
            }
        }

        it = setA.iterator();
        while(it.hasNext()) {
            setHab.add(it.next());
        }

        it = setB.iterator();
        while(it.hasNext()) {
            setHab.add(it.next());
        }

        System.out.println("A ∩ B = " + setKyo); // 교집합
        System.out.println("A ∪ B = " + setHab); // 합집합
        System.out.println("A - B = " + setCha); // 차집합

    }
}

11-39 TreeSet - 범위 탐색, 정렬

이진 탐색 트리(binary search tree)라는 자료구조의 형태로 데이터를 저장

정렬, 검색, 범위 검색에 유리리

이진 트리는 모든 노드가 최대 2개의 하위 노드를 갖음

각 요소(node)가 나무(tree)형태로 연결(LinkedList의 변형)

11-40 이진 탐색 트리(binary search tree)

💡

이진 탐색 트리(binary search tree)
- 모든 노드는 최대 두 개의 자식노드를 가질 수 있다.
- 왼쪽 자식노드의 값은 부모노드의 값보다 작고 오른쪽 자식노드의 값은 부모노드의 값보다 커야 한다.
- 노드의 추가 삭제에 시간이 걸린다.(순차적으로 저장하지 않으므로)
- 검색(범위검색)과 정렬에 유리하다.
- 중복된 값을 저장하지 못한다.

부모보다 작은 값은 왼쪽 큰 값은 오른쪽에 저장

데이터가 많아질 수록 추가, 삭제에 시간이 더 걸림(비교 횟수 증가)

11-41 TreeSet - 데이터 저장과정 `boolean add(Obejct o)`

TreeSet에 7,4,9,1,5의 순서로 데이터를 저장하면, 아래의 과정을 거친다.
(루트부터 트리를 따라 내려가며 값을 비교. 작으면 왼쪽, 크면 오른쪽에 저장)

11-42 TreeSet - 주요 생성자와 메서드

생성자 또는 메서드	설명
TreeSet()	기본 생성자
TreeSet(Collection c)	주어진 컬렉션을 저장하는 TreeSet을 생성
TreeSet(Comparator comp)	주어진 정렬기준으로 정렬하는 TreeSet을 생성
Object first()	정렬된 순서에서 첫 번째 객체를 반환한다.
Obejct last()	정렬된 순서에서 마지막 객체를 반환한다.
Object ceiling(Object o)	지정된 객체와 같은 객체를 반환, 없으면 큰 값을 가진 객체 중 제일 가까운 값의 객체를 반환. 없으면 null
Object floor(Object o)	지정된 객체와 같은 객체를 반환, 없으면 작은 값을 가진 객체 중 제일 가까운 값의 객체를 반환. 없으면 null
Object higher(Obejct o)	지정된 객체보다 큰 값을 가진 객체 중 제일 가까운 값의 객체를 반환. 없으면 null
Object lower(Obejct o)	지정된 객체보다 작은 값을 가진 객체 중 제일 가까운 값의 객체를 반환. 없으면 null
SortedSet subSet(Object fromElement, Object toElement)	범위 검색(fromElement와 toElement)의 결과를 반환한다.(끝 범위인 toElement는 범위에 포함되지 않음)
SortedSet headSet(Object toElement)	지정된 객체보다 작은 값의 객체들을 반환한다.
SortedSet tailSet(Object fromElement)	지정된 객체보다 큰 값의 객체들을 반환한다.

예제 11-13

Set set = new TreeSet();    // 범위 검색, 정렬. 정렬필요없음
// Set set = new HashSet(); // 정렬 필요

for (int i = 0; set.size() < 6; i++) {
    int num = (int)(Math.random() * 45) + 1; // 1 ~ 45까지의 랜덤한 숫자를 가져온다.
    set.add(num); // set.add(new Integer(num));
}

System.out.println(set);

TreeSet은 비교기준이 꼭 필요하다.

저장하는 객체가 Comparable을 가지고 있던가, TreeSet이 Comparator를 가지고 있던지 둘 중에 하나를 해야한다.

예제 11-14

TreeSet set = new TreeSet();

String from = "b";
String to = "d";

set.add("abc");      set.add("alien");    set.add("bat");
set.add("car");      set.add("Car");      set.add("disc");
set.add("dance");    set.add("dZZZZ");    set.add("dzzzz");
set.add("elephant"); set.add("elevator"); set.add("fan");
set.add("flower");

System.out.println(set);
System.out.println("range search : from " + from + " to " + to);
System.out.println("result1 : " + set.subSet(from, to));
System.out.println("result1 : " + set.subSet(from, "dpp"));
System.out.println("result1 : " + set.subSet(from, "d333"));
System.out.println("result1 : " + set.subSet(from, "dc"));

예제 11-15

TreeSet set = new TreeSet();
// Set set = new TreeSet();  // headSet, tailSet, subSet은 TreeSet의 메서드이기 때문에 참조변수의 타입을 Set으로 변경하면 안 된다.
int[] score = {80, 95, 50, 35, 45, 65, 10, 100};

for (int i = 0; i < score.length; i++) {
    set.add(new Integer(score[i]));
}

System.out.println("50보다 작은 값 : " + set.headSet(50));
System.out.println("50보다 큰 값 : " + set.tailSet(50));
System.out.println("40과 80사이의 값 : " + set.subSet(50, 80));

11-45 TreeSet - 예제3 범위검색 subSet(), headSet(), tailSet()

TreeSet은 범위검색에 유리한 메서드를 가지고 있다.

메서드	설명
SortedSet subSet(Object fromElement, Object toElement)	범위 검색(fromElement와 toElement)의 결과를 반환한다.(끝 범위인 toElement는 범위에 포함되지 않음)
SortedSet headSet(Object toElement)	지정된 객체보다 작은 값의 객체들을 반환한다.
SortedSet tailSet(Object fromElement)	지정된 객체보다 큰 값의 객체들을 반환한다.

트리 순회(tree traversal)

이진 트리의 모든 노드를 한번씩 읽는 것을 트리 순회라고 한다

전위, 중위 후위 순회법이 있으며, 중위 순회하면 오름차순으로 정렬된다.

전위순위(preorder)

부모를 먼저 읽음

후위순회(postorder)

부모를 나중에 읽음

중위순회(inorder)

부모를 가운데에 넣음

중외 순회하면 오름차순으로 정렬된다.

레벨순회

11-46 HashMap과 Hashtable - 순서X, 중복(키X, 값O)

Map 인터페이스를 구현. 데이터를 키(key)와 값(value)의 쌍으로 저장

HashMap(동기화X)은 Hashtable(동기화O)의 신버전

key - value 형태의 값이 필요하면 HashMap

HashMap

Map 인터페이스를 구현한 대표적인 컬렉션 클래스

순서를 유지하려면, LinkedHashMap 클래스를 사용하면 된다.

TreeMap

범위 검색과 정렬에 유리한 컬렉션 클래스

HashMap보다 데이터 추가, 삭제에 시간이 더 걸림

+) TreeSet은 TreeMap을 가지고 만든 것, key-value 형태로 저장하는 것만 제외하면 두 클래스는 동일하다.

11-47 HashMap의 키(key)와 값(value)

해싱(hashing)기법으로 데이터를 저장. 데이터가 많아도 검색이 빠르다.

Map 인터페이스를 구현. 데이터를 키와 값의 쌍으로 저장

💡

키(key) 컬렉션 내의 키(key)중에서 유일해야 한다.

값(value) 키(key)와 달리 데이터의 중복을 허용한다.

HashMap map = new HashMap();
map.put("myId", "1234");
map.put("asdf", "1111");
map.put("asdf", "1234");

// HashMap의 실제소스
public class HashMap extends AbstractMap
								implements Map, Cloneable, Serializable {
		transient Entry[] table;
		...
		static class Entry implements Map.Entry {
			final Object key;
			Object value;
			...
		}
}

HashMap은 Map을 구현했으므로 Map의 특징, 키(key)와 값(value)을 묶어서 하나의 데이터(entry)로 저장한다는 특징을 갖는다.

비객체지향적인 코드	객체지향적인 코드
Object[] key; Object[] value;	Entry[] table; class Entry { Object key; Object value; }

HashMap은 Entry라는 내부 클래스를 정의하고, 다시 Entry 타입의 배열을 선언하고 있다. 키(key)와 값(value)은 별개의 값이 아니라 서로 관련된 값이기 때문에 각각의 배열로 선언하기 보다는 하나의 클래스로 정의해서 하나의 배열로 다루는 것이 데이터의 무결성(integrity)적인 측면에서 더 바람직하기 때문이다.

해싱(hashing) - (1/3) 환자정보관리

해시함수(hash function)

해시함수에 key값을 넣으면 해쉬코드를 반환한다.

여기서 이 해쉬코드가 배열의 index(저장위치)

위의 환자정보가 들어있는 캐비넷에서 저장된 서랍이 몇 번째 칸에 있는지 알려주는 것이다.

즉 해당 키가 저장되어있는 위치를 쉽게 찾을 수 있다.

해싱(hashing) - (2/3)

정의 : 해시함수(hash function)로 해시테이블(hash table)에 데이터를 저장, 검색(읽어오기)

해시테이블은 배열과 링크드 리스트가 조합된 형태(장점만 가져왔다.)
길이가 가변적인 2차원 배열이라 table이라고 하는 거임
링크드 리스트로만 만들면 데이터 검색에 시간이 오래걸리기 때문에 분류해서 묶어둔 것이다. 해시함수의 결과인 배열의 index로 한번에 찾아가고, 그 안에 들어가서부턴 검색 속도가 느리지만 변경에 유리함으로 링크드리스트로 구현

why 링크드 리스트? ⇒ 변경이 쉬움
why 배열? ⇒ 접근성이 좋음(index만 알면 한번에 찾아갈 수 있다.)

Objects.hash() 메서드를 이용해 해시함수를 작성하면된 다

Objects.hash()를 이용해 hashCode()를 오버라이딩..?

→ ???? 먼솔??

해싱은 해시함수를 이용한 것이기 때문에 함수의 성능이 중요한데, Objects.hash() 메서드를 이용해서 작성하면 된다..???

해싱을 사용하는 클래스들

HashTable

HashMap

HashSet

→ hashCode()메서드를 사용함

이 메서드를 Objects.hash()를 이용해 hashCode()를 오버라이딩한다.

해싱(hashing) - (3/3)

해시테이블에 저장된 데이터를 가져오는 과정

① 키로 해시함수를 호출해서 해시코드를 얻는다.

② 해시코드(해시함수의 반환값)에 대응하는 링크드리스트를 배열에서 찾는다.

③ 링크드리스트에서 키와 일치하는 데이터를 찾는다.

※ 해시함수는 같은 키에 대해 항상 같은 해시코드를 반환해야 한다.

서로 다른 키일지라도 같은 값의 해시코드를 반환할 수도 있다.

11-48 HashMap - 주요 메서드

HashMap은 해시 테블에 데이터를 저장한다.(배열 + 링크드 리스트)

생성자 / 메서드	설명
HashMap()	HashMap 객체를 생성
HashMap(int initialCapacity)	지정된 값을 초기용량으로 하는 HashMap 객체를 생성
HashMap(int initialCapacity, float loadFactor)	지정된 초기용량과 load factor의 HashMap 객체를 생성
HashMap(Map m)	지정된 Map의 모든 요소를 포함하는 HashMap을 생성
void clear()	HashMap에 저장된 모든 객체를 제거
Object clone()	현재 HashMap을 복제해서 반환
boolean containsKey(Object key)	HashMap에 지정된 값(value)이 포함되어있는지 알려준다. (포함되어 있으면 true)
boolean containsValue(Object value)	HashMap에 지정된 값(value)이 포함되어있는지 알려준다. (포함되어 있으면 true)
Set entrySet()	HashMap에 저장된 키와 값을 엔트리(키와 값의 결합)의 형태로 Set에 저장해서 반환
Object get(Object key)	지정된 키(key)의 값(객체)을 반환. 못찾으면 null 반환
Object getOrDefault(Object key, Object defaultValue)	지정된 키(key)의 값(객체)을 반환한다. 키를 못찾으면, 기본값(defaultValue)으로 지정된 객체를 반환
boolean is Empty()	HashMap이 비어있는지 알려준다.
Set keySet()	HashMap에 저장된 모든 키가 저장된 Set을 반환
Object put(Object key, Object value)	지정된 키와 값을 HashMap에 저장
void putAll(Map m)	Map에 저장된 모든 요소를 HashMap에 저장
Object remove(Object key)	HashMap에서 지정된 키로 저장된 값(객체)을 제거
Object replace(Object key, Object value)	지정된 키의 값을 지정된 객체(value)로 대체
boolean replace(Object key, Object oldValue, Object newValue)	지정된 키와 객체(oldValue)가 모두 일치하는 경우에만 새로운 객체(newValue)로 대체
int size()	HashMap에 저장된 요소의 개수를 반환
Collection values()	HashMap에 저장된 모든 값을 컬렉션의 형태로 반환

예제 11-16

import java.util.HashMap;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("myId", "1234"); // id = myId, pw = 1234
        map.put("asdf", "1111");
        map.put("asdf", "1234");

        Scanner s = new Scanner(System.in);

        while (true) {
            System.out.println("id와 password를 입력해주세요.");
            System.out.print("id : ");
            // id를 공백제거해 String으로 입력받는다.
            String id = s.nextLine().trim();

            System.out.print("pw : ");
            // pw를 공백제거해 String으로 입력받는다.
            String password = s.nextLine().trim();
            System.out.println();

            if (!map.containsKey(id)) { // 입력한 id가 존재하는지 검증
                System.out.println("입력하신 id는 존재하지 않습니다." + " 다시 입력해주세요.");
                continue;
            } else {
                if (map.get(id).equals(password)) { // 입력한 id와 pw가 일치하는지 검증
                    System.out.println("id와 비밀번호가 일치합니다.");
                    break;
                } else {
                    System.out.println("비밀번호가 일치하지 않습니다. 다시 입력해주세요.");
                }
            }
        }
    }
}

예제 11-17

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("김자바", new Integer(90));
        map.put("김자바", new Integer(100));
        map.put("이자바", new Integer(100));
        map.put("강자바", new Integer(80));
        map.put("안자바", new Integer(90));

        System.out.println(map);
        System.out.println("####################");

        // HashMap은 Collection의 자손이 아니기 때문에 iterator 메서드 없음
        Set set = map.entrySet(); // HashMap에 저장된 키와 값을 엔트리(키와 값의 결합)의 형태로 Set에 저장해서 반환
        Iterator it = set.iterator();

        while (it.hasNext()) { // 읽어올 다음 요소가 있는지 확인
            Map.Entry e = (Map.Entry) it.next(); // 다음 요소를 가져온다.
            System.out.println("이름 : " + e.getKey() + ", 점수 : " + e.getValue());
        }

        set = map.keySet(); // map의 key들만 가져온다.
        System.out.println("참가자 명단 : " + set);

        Collection values = map.values(); // map의 value들만 가져온다.
        it = values.iterator();

        System.out.println("#### values ####" + values);
        System.out.println("#### 클래스 ####" + values.getClass().getName());

        int total = 0;

        while (it.hasNext()) {
            int i = (int) it.next();
            total += i;
        }

        System.out.println("총점 : " + total);
        System.out.println("평균 : " + (float) total/set.size());
        // Comparable을 구현한 클래스의 객체만 인수로 넣을 수 있다.
        System.out.println("최고점수 : " + Collections.max(values));
        System.out.println("최저점수 : " + Collections.min(values));

        // 


        
    }
}

예제 11-18

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class Main {
    public static void main(String[] args) {
        String[] data = { "A","K","A","K","D","K","A","K","K","K","Z","D" };
        
        HashMap map = new HashMap();

        for (int i = 0; i < data.length; i++) {
            if (map.containsKey(data[i])) { // map에 data의 i번째에 있는 값이 존재하면
                int value = (int) map.get(data[i]); // map에서 key = data[i]에 해당하는 value를 가져온다.
                 map.put(data[i], value + 1); // key = data[i]에 value값을 1 증가시킨다.
            // map에 data의 i번째에 있는 값이 존재하지 않으면
            } else {
                map.put(data[i], 1); // map에 key = data[i], value는 1로 값을 넣는다.
            }
        }

        Iterator it = map.entrySet().iterator(); // map에서 데이터를 entry(key, value 한쌍) 형태로 가져온 후 iterator를 반환한다.

        while (it.hasNext()) { // 읽어올 요소가 있는지 확인한다.
            Map.Entry entry = (Map.Entry) it.next(); // 다음 요소를 가져온다.
            int value = (int) entry.getValue(); // entry에서 value를 가져온다.
            System.out.println(entry.getKey() + " : "
                                        + printBar('#', value));
        }
        
    }

    // value의 수만큼 문자 ch를 반환하는 메서드
    public static String printBar(char ch, int value) {
        char[] bar = new char[value]; // length value 만큼의 char배열 생성

        for (int i = 0; i < bar.length; i++) {
            bar[i] = ch;
        }

        return new String(bar);
    }
}

11-52~54 Collections - 컬렉션을 위한 메서드(static)를 제공

💡

Objects - 객체
Arrays - 배열
Collections - 컬렉션

컬렉션 채우기, 복사, 정렬, 검색 - fill(), copy(), sort(), binarySearch()등

컬렉션의 동기화 - synchronizedXXX()

static Collection synchronizedCollection(Collection c)
static Collection synchronizedList(List list)
static Collection synchronizedSet(Set s)
static Collection synchronizedMap(Map m)
static Collection synchronizedSortedSet(SortedSet s)
static Collection synchronizedSortedMap(SortedMap m)`

Vector : 동기화 O

ArrayList : 동기화 X

동기화가 필요할 때만 동기화하도록 설계가 변경

List syncList = Collections.synchronizedList(new ArrayList(...));
// 동기화된 List                               // 동기화되지않은 List

변경불가(readOnly) 컬렉션 만들기 - unmodifiableXXX()

static Collection unmodifiableCollection(Collection c)
static Collection unmodifiableList(List list)
static Collection unmodifiableSet(Set s)
static Collection unmodifiableMap(Map m)
static Collection unmodifiableNavigableSet(NavigableSet s)
static Collection unmodifiableSortedSet(SortedSet s)
static Collection unmodifiableNavigableMap(NavigableMap m)
static Collection unmodifiableSortedMap(SortedMap m)

싱글톤 컬렉션 만들기 - singletonXXX()

static List singletonList(Object o)
static Set singleton(Object o) // singletonSet이 아님에 주의
static Map singletonMap(Object key, Object value)

한 종류의 객체만 저장하는 컬렉션 만들기 - checkedXXX()

= 제네릭

1.5 이전에 나온 클래스들은 checked로 시작하는 메서드를 이용해서 한 종류의 데이터만 저장하는 컬렉션을 만들어야한다.

이거 쓸 일은 거의 없음 존재한다는 정도만 알고 있으면 됨

static Collection   checkedCollection(Collection c, Class type)
static List         checkedList(List list, Class type)
static Set          checkedSet(Set s, Class type)
static Map          checkedMap(Map m, Class keyType, Class valueType)
static Queue        checkedQueue(Queue queue, Class type)
static NavigableSet checkedNavigableSet(NavigableSet s, Class type)
static SortedSet    checkedSortedSet(SortedSet s, Class type)
static NavigableMap checkedNavigableMap(NavigableMap m, Class keyType, Class valueType)
static SortedMap    checkedSortedMap(SortedMap m, class keyType, Class valueType)

List list = new ArrayList();
List checkedList = checkedList(list, String.class); // String만 저장가능
checkedList.add("abc"); // OK.
checkedList.add(new Integer(3)); // 에러. ClassCastException 발생

예제 11-19

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List list = new ArrayList();
        System.out.println(list);

        Iterator it = list.iterator();

        Collections.addAll(list, 1, 2, 3, 4, 5, 6);
        System.out.println("addAll : " + list);

        Collections.rotate(list, 2); // 반시계방향으로 두번 회전
        System.out.println("rotate : " + list);

        Collections.swap(list, 0, 2); // 첫 번째와 세 번째를 교환(swap)
        System.out.println("swap : " + list);

        Collections.shuffle(list); // 지정된 요소의 위치를 임의로 변경
        System.out.println("shuffle : " + list);

        Collections.sort(list); // 정렬
        System.out.println("sort : " + list);

        Collections.sort(list, Collections.reverseOrder());
        System.out.println("역순 sort : " + list);
        
        int idx = Collections.binarySearch(list, 3);
        System.out.println("idx of 3 = " + idx);

        System.out.println("max = " + Collections.max(list)); // 역순정렬상태인데 왜 값이 제대로 나옴..?
        System.out.println("min = " + Collections.min(list));
        System.out.println("min = " + Collections.max(list, Collections.reverseOrder()));

        Collections.fill(list, 9); // list를 9로 채운다.
        System.out.println("list = " + list);

        List newList = Collections.nCopies(list.size(), 2); // list와 같은 크기의 새로운 list를 생성하고 2로 채운다. 단, 결과는 변경불가
        System.out.println("newList = " + newList);

        System.out.println(Collections.disjoint(list, newList)); // 공통 요소가 없으면 true

        Collections.copy(list, newList);
        System.out.println("newList = " + newList);
        System.out.println("list = " + list);

    }
}

11-56 컬렉션 클래스 정리 & 요약

11챕터 연습문제

🏅11챕터 연습문제 (1)

11-6

import com.sun.source.tree.Tree;

import javax.xml.stream.events.StartDocument;
import java.lang.reflect.WildcardType;
import java.util.*;

class Student implements Comparable {
    String name;
    int ban;
    int no;
    int kor, eng, math;

    public Student(String name, int ban, int no, int kor, int eng, int math) {
        this.name = name;
        this.ban = ban;
        this.no = no;
        this.kor = kor;
        this.eng = eng;
        this.math = math;
    }

    int getTotal() {
        return kor + eng + math;
    }

    float getAverage() {
        return (int) ((getTotal() / 3f) * 10 + 0.5) / 10f;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", ban=" + ban +
                ", no=" + no +
                ", kor=" + kor +
                ", eng=" + eng +
                ", math=" + math +
                ", getTotal()" + getTotal() +
                ", getAverage()" + getAverage() +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        if (o instanceof Student) {
            Student st = (Student) o;
            return name.compareTo(st.name);
        } else {
            return -1;
        }
    }
}

public class Main {
    // 평균점수의 범위를 주면 해당 범위에 속한 학생의 수를 반환하는 getGroupCount()를 완성하라.
    static int getGroupCount(TreeSet tset, int from, int to) {
        TreeSet avgTreeSet = new TreeSet();
        Iterator it = tset.iterator();

        while (it.hasNext()) {
            Student s1 = (Student) it.next();
            avgTreeSet.add((int) s1.getAverage());
        }

        return avgTreeSet.subSet(from, to).size();
    }

    /**
     * 성적평균의 범위별로 학생 수를 세기 위한 것이다.
     * TreeSet이 학생들의 평균을 기준으로 정렬하도록 compare(Object o1, Object o2)와
     * 평균점수의 범위를 주면 해당 범위에 속한 학생의 수를 반환하는 getGroupCount()를 완성하라.
     *
     * @param args
     */
    public static void main(String[] args) {
        TreeSet set = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Student && o2 instanceof Student) {
                    Float avg1 = ((Student) o1).getAverage();
                    Float avg2 = ((Student) o2).getAverage();

                    return avg1.compareTo(avg2);
                } else {
                    return -1;
                }
            }
        });

        set.add(new Student("홍길동", 1, 1, 100, 100, 100));
        set.add(new Student("남궁성", 1, 2, 90, 70, 80));
        set.add(new Student("김자바", 1, 3, 80, 80, 90));
        set.add(new Student("이자바", 1, 4, 70, 90, 70));
        set.add(new Student("안자바", 1, 5, 60, 100, 80));

        Iterator it = set.iterator();

        while (it.hasNext()) {
            System.out.println(it.next());
        }

        System.out.println("[60~69] : " + getGroupCount(set, 60, 70));
        System.out.println("[70~79] : " + getGroupCount(set, 70, 80));
        System.out.println("[80~89] : " + getGroupCount(set, 80, 90));
        System.out.println("[90~100] : " + getGroupCount(set, 90, 101));

    }
}

11-7

import com.sun.source.tree.Tree;

import javax.xml.stream.events.StartDocument;
import java.lang.reflect.WildcardType;
import java.util.*;

class Student {
    String name;
    int ban;
    int no;
    int kor, eng, math;

    public Student(String name, int ban, int no, int kor, int eng, int math) {
        this.name = name;
        this.ban = ban;
        this.no = no;
        this.kor = kor;
        this.eng = eng;
        this.math = math;
    }

    int getTotal() {
        return kor + eng + math;
    }

    float getAverage() {
        return (int) ((getTotal() / 3f) * 10 + 0.5) / 10f;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", ban=" + ban +
                ", no=" + no +
                ", kor=" + kor +
                ", eng=" + eng +
                ", math=" + math +
                ", getTotal()" + getTotal() +
                ", getAverage()" + getAverage() +
                '}';
    }

}

// 반(ban)과 번호(no)로 오름차순 정렬되게 (반이 같은 경우 번호를 비교해서 저장한다.)
class BanNoAscending implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        if (!(o1 instanceof Student && o2 instanceof Student)) return -1;

        Student s1 = (Student) o1;
        Student s2 = (Student) o2;
        Integer ban1 = s1.ban;
        Integer ban2 = s2.ban;

        if (ban1 != ban2) {
            return ban1.compareTo(ban2);
        } else {
            Integer no1 = (Integer) s1.no;
            Integer no2 = (Integer) s2.no;

            return no1.compareTo(no2);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Student("이자바", 2, 2, 90, 70, 80));
        list.add(new Student("안자바", 2, 2, 80, 80, 90));
        list.add(new Student("홍길동", 1, 3, 80, 80, 90));
        list.add(new Student("남궁성", 1, 1, 70, 90, 70));
        list.add(new Student("김자바", 1, 2, 60, 100, 80));

        Collections.sort(list, new BanNoAscending());

        Iterator it = list.iterator();

        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

11-8

import com.sun.source.tree.Tree;

import javax.xml.stream.events.StartDocument;
import java.lang.reflect.WildcardType;
import java.util.*;

class Student implements Comparable {
    String name;
    int ban;
    int no;
    int kor;
    int eng;
    int math;

    int total; // 총점
    int schoolRank; // 전교등ㄹ수

    public Student(String name, int ban, int no, int kor, int eng, int math) {
        this.name = name;
        this.ban = ban;
        this.no = no;
        this.kor = kor;
        this.eng = eng;
        this.math = math;

        total = kor + eng + math;
    }

    int getTotal() {
        return kor + eng + math;
    }

    float getAverage() {
        return (int) ((getTotal() / 3f) * 10 + 0.5) / 10f;
    }

    @Override
    public String toString() {
//        return "Student{" +
//                "name='" + name + '\'' +
//                ", ban=" + ban +
//                ", no=" + no +
//                ", kor=" + kor +
//                ", eng=" + eng +
//                ", math=" + math +
//                ", getTotal()" + getTotal() +
//                ", getAverage()" + getAverage() +
//                '}';
        return "총점 : " + total + ", 등수 : " + schoolRank;
    }

    // 총점을 기준으로 내림차순
    @Override
    public int compareTo(Object o) {
        if (o instanceof Student) {
            Integer total1 = getTotal();
            Integer total2 = ((Student) o).getTotal();

            return total1.compareTo(total2) * -1;
        } else {
            return -1;
        }
    }
}

public class Main {
    // 총점을 기준으로 각 학생의 전교등수 를 계산하고 전교등수를 기준으로 오름차순 정렬하여 출력
    public static void calculateSchoolRank(List list) {
        Collections.sort(list); // 먼저 list를 총점 기준 내림차순으로 정렬한다.

        int prevRank = 0;  // 이전 전교등수
        int prevTotal = 0; // 이전 총점
        int length = list.size();

        for (int i = 0; i < length; i++) {
            Student s1 = (Student) list.get(i);
            if (s1.total == prevTotal) { // 총점이 이전총점과 같으면
                s1.schoolRank = prevRank; // 이전 등수를 등수로 한다.
            } else { // 총점이 서로 다를 경우
                s1.schoolRank = i+1;

                prevRank = s1.schoolRank;
                prevTotal = s1.total;
            }
        }

    }

    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Student("이자바", 2, 2, 90, 70, 80));
        list.add(new Student("안자바", 2, 2, 80, 80, 90));
        list.add(new Student("홍길동", 1, 3, 80, 80, 90));
        list.add(new Student("남궁성", 1, 1, 70, 90, 70));
        list.add(new Student("김자바", 1, 2, 60, 100, 80));

        calculateSchoolRank(list);

        Iterator it = list.iterator();

        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

11-9

import com.sun.source.tree.Tree;

import javax.xml.stream.events.StartDocument;
import java.lang.reflect.WildcardType;
import java.util.*;

class Student implements Comparable {
    String name;
    int ban;
    int no;
    int kor;
    int eng;
    int math;

    int total;      // 총점
    int schoolRank; // 전교등수
    int classRank;  // 반등수

    public Student(String name, int ban, int no, int kor, int eng, int math) {
        this.name = name;
        this.ban = ban;
        this.no = no;
        this.kor = kor;
        this.eng = eng;
        this.math = math;

        total = kor + eng + math;
    }

    int getTotal() {
        return kor + eng + math;
    }

    float getAverage() {
        return (int) ((getTotal() / 3f) * 10 + 0.5) / 10f;
    }

    // 총점을 기준으로 내림차순
    @Override
    public int compareTo(Object o) {
        if (o instanceof Student) {
            Student tmp = (Student) o;
            return tmp.total - this.total;
        } else {
            return -1;
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", ban=" + ban +
                ", no=" + no +
                ", kor=" + kor +
                ", eng=" + eng +
                ", math=" + math +
                ", total=" + total +
                ", schoolRank=" + schoolRank +
                ", classRank=" + classRank +
                '}';
    }
}

/**
 * 총점을 기준으로 정렬하는데 여기서 반이 같으면..??
 * 기본 정렬이 반 기준으로 되어야 할 것 같은데
 * 1. 반 기준으로 정렬하고
 * 2. 반이 같으면 총점으로 정렬
 */
class ClassTotalComparator implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        if (!(o1 instanceof Student && o2 instanceof Student)) return -1;
        Student s1 = (Student) o1;
        Student s2 = (Student) o2;

        if (s1.ban != s2.ban) { // 1. 반 기준으로 정렬
            return s1.ban - s2.ban;
        } else { // 2. 반이 같으면 총점을 기준으로 정렬한다.
            return (s1.total - s2.total) * -1;
        }
    }
}

public class Main {
    /**
     * 반등수 계산
     * 1. 반이 달라지면, (ban과 prevBan)이 다르면
     *    이전 등수(prevRank)와 이전 총점(prevTotal)을 초기화한다.
     * 2. 총점(total)이 이전 총점(prevTotal)과 같으면
     *    이전 등수(prevRank)를 등수(classRank)로 한다.
     * 3. 총점이 서로 다르면,
     *    등수(classRank)의 값을 알맞게 계산해서 저장한다.
     *    이전에 동점자였다면, 그 다음 등수는 동점자의 수를 고려해야 한다.
     * 4. 현재 반과 총점과 등수를 이전 반(prevBan),
     *    이전 총점(prevTotal), 이전 등수(prevRank)에 저장한다.
     */
    public static void calculateClassRank(List list) {
        Collections.sort(list, new ClassTotalComparator());

        int prevBan = -1;
        int prevRank = -1;
        int prevTotal = -1;
        int length = list.size();

        for (int i = 0; i < length; i++) {
            Student s = (Student) list.get(i);

            if (s.ban != prevBan) {
                prevRank = -1;
                prevTotal = -1;
            }

            if (s.total == prevTotal) {
                s.classRank = prevRank;
            } else {
                s.classRank = (s.ban == prevBan) ? prevRank + 1 : 1;

                prevBan = s.ban;
                prevTotal = s.total;
                prevRank = s.classRank;
            }
        }
    }

    // 전교등수 계산
    public static void calculateSchoolRank(List list) {
        Collections.sort(list); // 먼저 list를 총점 기준 내림차순으로 정렬한다.

        int prevRank = 0;  // 이전 전교등수
        int prevTotal = 0; // 이전 총점
        int length = list.size();

        for (int i = 0; i < length; i++) {
            Student s1 = (Student) list.get(i);
            if (s1.total == prevTotal) { // 총점이 이전총점과 같으면
                s1.schoolRank = prevRank; // 이전 등수를 등수로 한다.
            } else { // 총점이 서로 다를 경우
                s1.schoolRank = i+1;

                prevRank = s1.schoolRank;
                prevTotal = s1.total;
            }
        }

    }

    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Student("이자바", 2, 1, 70, 90, 70));
        list.add(new Student("안자바", 2, 2, 60, 100, 80));
        list.add(new Student("홍길동", 1, 3, 100, 100, 100));
        list.add(new Student("남궁성", 1, 1, 90, 70, 80));
        list.add(new Student("김자바", 1, 2, 80, 80, 90));

        calculateSchoolRank(list);
        calculateClassRank(list);

//        Collections.sort(list, new ClassTotalComparator());
        Iterator it = list.iterator();

        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

11-12

package ch11.exercise;

import java.lang.management.PlatformLoggingMXBean;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class Exercise11_12 {
    public static void main(String[] args) throws Exception {
        SutdaDeck deck = new SutdaDeck();

        deck.shuffle();

        Player p1 = new Player("타짜", deck.pick(), deck.pick());
        Player p2 = new Player("고수", deck.pick(), deck.pick());

        System.out.println(p1 + " " + deck.getPoint(p1));
        System.out.println(p2 + " " + deck.getPoint(p2));

    }
}

class SutdaDeck {
    final int CARD_NUM = 20;
    SutdaCard[] cards = new SutdaCard[CARD_NUM];

    int pos = 0;
    HashMap<String, Integer> jokbo = new HashMap<>();

    SutdaDeck() {
        for (int i = 0; i < cards.length; i++) {
            int num = i & 10 + 1;
            boolean isKwang = i < 10 && (num == 1 || num == 3 || num == 8);

            cards[i] = new SutdaCard(num, isKwang);
        }
        registerJokbo();
    }

    void registerJokbo() {
        /**
         * jokbo(HashMap)에 족보를 저장한다.
         * 두 카드의 값을 문자열로 붙여서 key로, 점수를 value로 저장한다.
         */

        int point = 3000;
        jokbo.put("KK", 4000);
        for (int i = 1; i <= 10; i++) {
            for (int j = 1; j <= 10; j++) {
                if (i == j) {
                    jokbo.put(i + "" + j, point+=10);
                }
            }
        }

        jokbo.put("12", 2060);
        jokbo.put("21", 2060);
        jokbo.put("14", 2050);
        jokbo.put("41", 2050);
        jokbo.put("19", 2040);
        jokbo.put("91", 2040);
        jokbo.put("110", 2030);
        jokbo.put("101", 2030);
        jokbo.put("410", 2020);
        jokbo.put("104", 2020);
        jokbo.put("46", 2010);
        jokbo.put("64", 2010);


        for (Map.Entry<String, Integer> entry : jokbo.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }

    int getPoint(Player p) {
        if (p == null) return 0;

        SutdaCard c1 = p.c1;
        SutdaCard c2 = p.c2;

        Integer result = 0;

        /**
         * 1. 카드 두 장이 모두 광이면, jokbo에서 키를 "KK"로 해서 점수를 조회한다.
         * 2. 두 카드의 숫자(num)로 jokbo에서 등급을 조회한다.
         * 3. 해당하는 등급이 없으면, 아래의 공식으로 점수를 계산한다.
         *    (c1.num + c2.num) % 10 + 1000
         * 4. Player의 점수(point)에 계산한 값을 저장한다.
         */

        if (c1.isKwang && c2.isKwang) {
            result = jokbo.get("KK");
        } else if (jokbo.containsKey(c1.num + "" + c2.num)) {
            result = jokbo.get(c1.num + "" + c2.num);
        } else {
            result = (c1.num + c2.num) % 10 + 1000;
        }

        p.point = result;

        return result.intValue();
    }

    SutdaCard pick() throws Exception {
        SutdaCard c = null;

        if (0 <= pos && pos < CARD_NUM) {
            c = cards[pos];
            cards[pos++] = null;
        } else {
            throw new Exception("남아있는 카드가 없습니다.");
        }

        return c;
    }

    void shuffle() {
        for (int x = 0; x < CARD_NUM; x++) {
            int i = (int) (Math.random() * CARD_NUM);
            int j = (int) (Math.random() * CARD_NUM);

            SutdaCard tmp = cards[i];
            cards[i] = cards[j];
            cards[j] = tmp;
        }
    }
}

class Player {
    String name;
    SutdaCard c1;
    SutdaCard c2;

    int point;

    Player(String name, SutdaCard c1, SutdaCard c2) {
        this.name = name;
        this.c1 = c1;
        this.c2 = c2;
    }

    @Override
    public String toString() {
        return "[" + name + "]" + c1.toString() + "," + c2.toString();
    }
}

class SutdaCard {
    int num;
    boolean isKwang;

    SutdaCard() {
        this(1, true);
    }

    SutdaCard(int num, boolean isKwang) {
        this.num = num;
        this.isKwang = isKwang;
    }

    @Override
    public String toString() {
        return num + (isKwang ? "K" : "");
    }
}

11-13

package ch11.exercise;

import com.sun.source.tree.Tree;

import java.lang.management.PlatformLoggingMXBean;
import java.util.*;

public class Exercise11_12 {
    public static void main(String[] args) throws Exception {
        SutdaDeck deck = new SutdaDeck();

        deck.shuffle();

        Player[] pArr = {
            new Player("타짜", deck.pick(), deck.pick())
          , new Player("고수", deck.pick(), deck.pick())
          , new Player("물주", deck.pick(), deck.pick())
          , new Player("중수", deck.pick(), deck.pick())
          , new Player("하수", deck.pick(), deck.pick())
        };

        TreeMap<Player, Integer> rank = new TreeMap<>(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Player && o2 instanceof Player) {
                    Player p1 = (Player) o1;
                    Player p2 = (Player) o2;

                    return (p1.point - p2.point) * -1;
                } else return -1;
            }
        });

        for (int i = 0; i < pArr.length; i++) {
            Player p = pArr[i];
            rank.put(p, deck.getPoint(p));
            System.out.println(p + " " + deck.getPoint(p));
        }
        System.out.println();
        System.out.println("1위는 " + rank.firstKey() + "입니다.");

        for (Map.Entry<Player, Integer> test : rank.entrySet()) {
            System.out.println(test.getKey() + ", 점수 : " + test.getValue());
        }
    }
}

class SutdaDeck {
    final int CARD_NUM = 20;
    SutdaCard[] cards = new SutdaCard[CARD_NUM];

    int pos = 0;
    HashMap<String, Integer> jokbo = new HashMap<>();

    SutdaDeck() {
        for (int i = 0; i < cards.length; i++) {
            int num = i & 10 + 1;
            boolean isKwang = i < 10 && (num == 1 || num == 3 || num == 8);

            cards[i] = new SutdaCard(num, isKwang);
        }
        registerJokbo();
    }

    void registerJokbo() {
        /**
         * jokbo(HashMap)에 족보를 저장한다.
         * 두 카드의 값을 문자열로 붙여서 key로, 점수를 value로 저장한다.
         */

        int point = 3000;
        jokbo.put("KK", 4000);
        for (int i = 1; i <= 10; i++) {
            for (int j = 1; j <= 10; j++) {
                if (i == j) {
                    jokbo.put(i + "" + j, point+=10);
                }
            }
        }

        jokbo.put("12", 2060);
        jokbo.put("21", 2060);
        jokbo.put("14", 2050);
        jokbo.put("41", 2050);
        jokbo.put("19", 2040);
        jokbo.put("91", 2040);
        jokbo.put("110", 2030);
        jokbo.put("101", 2030);
        jokbo.put("410", 2020);
        jokbo.put("104", 2020);
        jokbo.put("46", 2010);
        jokbo.put("64", 2010);


//        for (Map.Entry<String, Integer> entry : jokbo.entrySet()) {
//            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
//        }
    }

    int getPoint(Player p) {
        if (p == null) return 0;

        SutdaCard c1 = p.c1;
        SutdaCard c2 = p.c2;

        Integer result = 0;

        /**
         * 1. 카드 두 장이 모두 광이면, jokbo에서 키를 "KK"로 해서 점수를 조회한다.
         * 2. 두 카드의 숫자(num)로 jokbo에서 등급을 조회한다.
         * 3. 해당하는 등급이 없으면, 아래의 공식으로 점수를 계산한다.
         *    (c1.num + c2.num) % 10 + 1000
         * 4. Player의 점수(point)에 계산한 값을 저장한다.
         */

        if (c1.isKwang && c2.isKwang) {
            result = jokbo.get("KK");
        } else if (jokbo.containsKey(c1.num + "" + c2.num)) {
            result = jokbo.get(c1.num + "" + c2.num);
        } else {
            result = (c1.num + c2.num) % 10 + 1000;
        }

        p.point = result;

        return result.intValue();
    }

    SutdaCard pick() throws Exception {
        SutdaCard c = null;

        if (0 <= pos && pos < CARD_NUM) {
            c = cards[pos];
            cards[pos++] = null;
        } else {
            throw new Exception("남아있는 카드가 없습니다.");
        }

        return c;
    }

    void shuffle() {
        for (int x = 0; x < CARD_NUM; x++) {
            int i = (int) (Math.random() * CARD_NUM);
            int j = (int) (Math.random() * CARD_NUM);

            SutdaCard tmp = cards[i];
            cards[i] = cards[j];
            cards[j] = tmp;
        }
    }
}

class Player {
    String name;
    SutdaCard c1;
    SutdaCard c2;

    int point;

    Player(String name, SutdaCard c1, SutdaCard c2) {
        this.name = name;
        this.c1 = c1;
        this.c2 = c2;
    }

    @Override
    public String toString() {
        return "[" + name + "]" + c1.toString() + "," + c2.toString();
    }
}

class SutdaCard {
    int num;
    boolean isKwang;

    SutdaCard() {
        this(1, true);
    }

    SutdaCard(int num, boolean isKwang) {
        this.num = num;
        this.isKwang = isKwang;
    }

    @Override
    public String toString() {
        return num + (isKwang ? "K" : "");
    }
}

Uploaded by N2T