Java - ArrayList, LinkedList, Stack, Queue, Iterator, ListIterator, Comparator, HashSet, TreeSet, HashMap, Set

주요내용 : 

package Week02.day0717;

import java.sql.Date;
import java.text.DecimalFormat;
import java.text.MessageFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;

class Army{
	private String name;
	private int age;
	private String grade;
	private String strDt; //복무기간(시작~끝)
	private String endDt;
	private Date nextHoliday; // 다음휴가일
	private Army[] sub = new Army[4]; // 부하병사들(sub)
	private int bonus;
	private int subCnt;
	
	Army(String name, int age, String grade, String strDt, String endDt) {
		this.name = name;
		this.age = age;
		this.grade = grade; // 계급
		this.strDt = strDt; 
		this.endDt = endDt;
	}
	
	public int getOverTimePayByClass() { // class별야근수당 리턴 , 일병: 100,000, 상병: 200,000, 병장: 300,000
			switch(grade) {
				case "병장":
					bonus+=300000;
					break;
				case "상병":
					bonus+=200000;
					break;
				case "일병":
					bonus+=100000;
					break;
			}
			return bonus;
	}
	
	public void printSubOverTimePay(Army[] sub) {// 부하별야근수당을 출력한다. 형식: ‘{0} 의야근수당은 {1} 입니다’ 금액은 3자리마다,를 찍어 표시한다, message format 쓰기
		DecimalFormat df = new DecimalFormat("#,###");
		for(int i=0; i<sub.length; i++) {
			String msg = "{0} {1} 의 야근수당은 {2} 원입니다.";
			Object[] arguments = {sub[i].grade, sub[i].name, df.format(sub[i].getOverTimePayByClass())};
			String result = MessageFormat.format(msg, arguments);
			System.out.println(result);
		}
	}
	
	public void getThisMMPeriod() throws ParseException { // 남은 복무기간. (끝날짜 - 현재날짜)
		
//		return (today.getActualMaximum(Calendar.DATE) - today.get(Calendar.DATE)); // 이번달의 남은 근무기간을 리턴한다. 
		
		String endDt1 = endDt;
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		Calendar c1 = Calendar.getInstance();
		String nowDt = sdf.format(c1.getTime());
		java.util.Date nowDt1 = sdf.parse(nowDt);
		java.util.Date endDt2 =  sdf.parse(endDt);
		long diff = endDt2.getTime() - nowDt1.getTime();
		long diffDays = diff / (24 * 60 * 60 * 1000);
		System.out.println(name + "님의 남은 복무기간은 = " + diffDays + "일 입니다.");
	}
	
//	public int getSubTotalPeriod() { // 부하들의총 근무기간을 리턴한다. 일수로 리턴. (현재날짜 - 첫날짜)
//		int endDt2 = Integer.parseInt(endDt);
//		int startDt1 = Integer.parseInt(strDt);
//		int period = endDt2 - startDt1;
//		return name + "님의 총 복무기간은 = " + period + "개월 입니다.";
//	}
//	
//	public boolean checkSub(Army[] sub) { // 모두 본인의 부하인지 리턴한다. Army간 비교는 name/age/class가 동일하면 동일인이다
//				//Army[] sub에 배열을 담아 파라미터로 던지면 부하인지 물어보는것. true, false로 리턴.
//				//부하들 sub에 담는다.
//	}
	
	public void returnSub(Army[] sub) { // 부하들 목록을 리턴한다
		System.out.println("======"+name+"님의 부하들======");
		for(int i=0; i<sub.length; i++) {
			System.out.println("이름 = " + sub[i].name +", 계급 = " + sub[i].grade);
		}
	}
	
	public void printSub(Army[] sub) throws ParseException { // 부하들을 출력한다
		for(int i=0; i<sub.length; i++) {
			SimpleDateFormat origianl_format = new SimpleDateFormat("yyyymmdd");
			SimpleDateFormat new_format = new SimpleDateFormat("yyyy-mm-dd");
			
			java.util.Date Start_origianl_date = origianl_format.parse(sub[i].strDt);
			String Start_new_date = new_format.format(Start_origianl_date);
			
			java.util.Date End_origianl_date = origianl_format.parse(sub[i].endDt);
			String End_new_date = new_format.format(End_origianl_date);
			if(sub[i]!=null && sub[i] instanceof SpecialArmy)
				System.out.println("우수병사 " + sub[i].grade + " " + sub[i].name + " " + Start_new_date + "~" + End_new_date);
			else
				System.out.println(sub[i].grade + " " + sub[i].name + " " + Start_new_date + "~" + End_new_date);
		}
//        병장 홍길동 2019-01-01 ~ 2020-12-31
//        우수  상병 김길동 2018-01-01 ~ 2021-05-31
	}
	
}

class SpecialArmy extends Army{ // 우수군인. 야근수당 bonus
	private static int bonus; // 야근수당에 bonus가 추가된다
	
	SpecialArmy(String name, int age, String grade, String strDt, String endDt, int bonus){
		super(name, age, grade, strDt, endDt);
		this.bonus = bonus;
	}

	public int getBonus() {
		return bonus;
	}

	public void setBonus(int bonus) {
		this.bonus = bonus;
	}
	
}

public class 실습7일차 {
	public static void main(String[] args) throws ParseException {
		
		Army ar = new Army("이수원", 50, "중령", "19800101", "20200101");
		
		Army[] sub = new Army[4];
		sub[0] = new Army("홍길동", 24, "병장", "20190101", "20201231");
		sub[1] = new Army("김형도", 23, "상병", "20110101", "20130101");
		sub[2] = new Army("김병식", 22, "일병", "20120101", "20140101");
		
		SpecialArmy as = new SpecialArmy("김길동", 20, "상병", "20180101", "20210531", 500000);
		
		sub[3] = as;
		
		ar.returnSub(sub);
		ar.getOverTimePayByClass();
		ar.printSubOverTimePay(sub);
		ar.getThisMMPeriod();
		ar.printSub(sub);
//		ar.getSubTotalPeriod();
//		ar.checkSub();
		
		
		

	}

}
--------------------------------------------------------------------------

package Week02.day0717;

import java.util.ArrayList;
import java.util.Collections;

public class ArrayListEx1 {

	public static void main(String[] args) {
		
		ArrayList list1 = new ArrayList(10);
		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);
		//list1 : [5, 4, 2, 0, 1, 3]
		//list2 : [4, 2, 0]
		
		Collections.sort(list1); //list1과 list2를 정렬한다.
		Collections.sort(list2); // Collections.sort(List l)
		print(list1, list2);
//		list1 : [0, 1, 2, 3, 4, 5]
//		list2 : [0, 2, 4]
		
		System.out.println("list1.containsAll(list2):" + list1.containsAll(list2)); // true
		
		list2.add("B");
		list2.add("C");
		list2.add(3, "A");
		print(list1, list2);
//		list1 : [0, 1, 2, 3, 4, 5]
//		list2 : [0, 2, 4, A, B, C]
		
		list2.set(3, "AA");
		print(list1, list2);
//		list1 : [0, 1, 2, 3, 4, 5]
//		list2 : [0, 2, 4, AA, B, C]
		
		//list1에서 list2와 겹치는 부분만 남기고 나머지는 삭제한다.
		System.out.println("list1.retainAll(list2): " + list1.retainAll(list2)); // true
		print(list1, list2);
//		list1 : [0, 2, 4]
//		list2 : [0, 2, 4, AA, B, C]
		
		//list2에서 list1에 포함된 객체들을 삭제한다.
		for(int i=list2.size()-1; i>=0; i--) {
			if(list1.contains(list2.get(i)))
				list2.remove(i);
		}
		print(list1, list2);
//		list1 : [0, 2, 4]
//		list2 : [AA, B, C]

	} // main의 끝

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

package Week02.day0717;

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

public class ArrayListEx2 {

	public static void main(String[] args) {
		final int LIMIT = 10; // 자르고자 하는 글자의 개수를 지정한다.
		String source = "0123456789abcdefghijABCDEFGHIJ@#$%^&*()ZZZ";
		int length = source.length();
		
		ArrayList list = new ArrayList(length/LIMIT + 10); // 크기를 약간 여유 있게 잡는다.
		
		for(int i=0; i<length; i+=LIMIT) {
			if(i+LIMIT < length)
				list.add(source.substring(i, i+LIMIT));
			else
				list.add(source.substring(i));
		}
		
		for(int i=0; i<list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		/*0123456789
		abcdefghij
		ABCDEFGHIJ
		@#$%^&*()Z
		ZZ
		 */
		
	}// main()
}

--------------------------------------------------------------------------
package Week02.day0717;

import java.util.ArrayList;
import java.util.Collections;

public class ArrayListEx3 {

	public static void main(String[] args) {
		ArrayList a = new ArrayList();
		
		Book3 b1 = new Book3("CC");
		Book3 b2 = new Book3("AA");
		Book3 b3 = new Book3("BB");
		
		a.add(b1); a.add(b2); a.add(b3);
		
		Collections.sort(a); //sort없이 출력하면 순서대로 찍힘. 그리고 compareTo를 쓰기때문에 오류남.
		
		System.out.println(a); // [AA, BB, CC]
	}
}

class Book3 implements Comparable{ // Comparable : 별도기준 x, Comparator : 별도기준O
	private String title;
	public Book3(String t) {title=t;}
	public String getTitle() {return title;}
	public String toString() {return title;}
	
	public int compareTo(Object obj) { // compareTo 재정의.
		Book3 book = (Book3)obj;
		return title.compareTo(book.getTitle());
	}
}
--------------------------------------------------------------------------

package Week02.day0717;

public class LinkedListEx1 {

	public static void main(String[] args) {
		
		//LinkedList 구조. 많이 사용됨. 다른 프로그래밍에서도 기초지식이 됨. 이해잘해놓을 것.
		
		LinkedList list = new LinkedList();
		System.out.println("(1) 공백 리스트에 노드 3개 삽입하기");
		list.insertLastNode("월");
		list.insertLastNode("수");
		list.insertLastNode("일");
		list.printList(); // [월 수 일]
		
		System.out.println("(2) \"수\"노드 뒤에 \"금\" 노드 삽입하기");
		ListNode pre = list.searchNode("수");
		
		if(pre==null) {
			System.out.println("검색 실패 >> 찾는 데이터가 없습니다.");
		} else {
			list.insertMiddleNode(pre, "금");
		}
		list.printList(); // [월 수 금 일]
		
		System.out.println("(3) 리스트의 첫번째에 노드 추가하기");
		list.insertFirstNode("토");
		list.printList(); // [토 월 수 금 일]
		
		System.out.println("(4) 리스트의 마지막 노드 삭제하기");
		list.deleteLastNode();
		list.printList(); // [토 월 수 금]
		
		System.out.println("(5) 리스트의 중간 노드 \"수\" 삭제하기");
		list.deleteMiddleNode("수");
		list.printList(); // [토 월 금]
		
		System.out.println("(6) 리스트의 첫번째 노드 삭제하기");
		list.deleteFirstNode();
		list.printList(); // [월 금]
		
		System.out.println("(7) 리스트의 역순으로 출력하기");
		list.reverseList();
		list.printList(); // [금 월]
	}
}

class ListNode{
	String data;
	ListNode next;
	
	public ListNode() { // 정보를 가지고 있는애.
		this.data = null;
		this.next = null;
	}
	
	public ListNode(String data) {
		this.data = data;
		this.next = null;
	}
	
	public ListNode(String data, ListNode next) {
		this.data = data;
		this.next = next;
		this.next = null;
	}
	
	public String getData() {
		return this.data;
	}
}

class LinkedList{
	private ListNode head;
	
	public LinkedList() { // 컨트롤 하는애. 시작점을 가지고 있고, 연결만 해줌.
		this.head = null;
	}
	
	void insertLastNode(String str) {
		ListNode node = new ListNode(str);
		if(head == null) {
			head = node;
		} else {
			ListNode current = head;
			while(current.next != null) {
				current = current.next;
			}
			current.next = node;
		}
	}
	
	void insertMiddleNode(ListNode pre, String str) {
		ListNode node = new ListNode(str);
		if(head == null) {
			head = node;
		} else {
			ListNode current = head;
			while(current.next != pre) {
				current = current.next;
			}
			current = current.next;
			node.next = current.next;
			current.next = node;
		}
	}
	
	void insertFirstNode(String str) {
		ListNode node = new ListNode(str);
		if(head == null) {
			head = node;
		} else {
			ListNode current = head;
			node.next = current;
			head = node;
		}
	}
	
	void deleteLastNode() {
		if(head == null) {
			System.out.println("지울 노드가 존재하지 않습니다.");
		} else {
			ListNode prev = head;
			ListNode current = head;
			while(current.next != null) {
				prev = current;
				current = current.next;
			}
			prev.next = null;
		}
	}
	
	void deleteMiddleNode(String str) {
		ListNode node = new ListNode(str);
		if(head == null) {
			System.out.println("지울 노드가 존재하지 않습니다.");
		} else {
			ListNode prev = head;
			ListNode current = head.next;
			while(current.data != node.data) {
				prev = current;
				current = current.next;
			}
			prev.next = current.next;
		}
	}
	
	void deleteFirstNode() {
		if(head == null) {
			System.out.println("지울 노드가 존재하지 않습니다.");
		} else {
			head = head.next;
		}
	}
	
	ListNode searchNode(String str) {
		ListNode node = new ListNode(str);
		if(head == null) {
			System.out.println("노드가 비어있습니다.");
			return null;
		} else {
			ListNode current = head;
			while(current.data != node.data) {
				current = current.next;
			}
			return current;
		}
	}
	
	void reverseList() {
		ListNode next = head;
		ListNode current = null;
		ListNode prev = null;
		
		while(next != null) {
			prev = current;
			current = next;
			next = next.next;
			current.next = prev;
		}
		head = current;
	}
	
	void printList() {
		if(head == null) {
			System.out.println("출력할 리스트가 존재하지 않습니다.");
		} else {
			ListNode current = head;
			System.out.print("[");
			while(current.next != null) {
				System.out.print(current.data + " ");
				current = current.next;
			}
			System.out.print(current.data);
			System.out.print("]");
			System.out.println();
		}
	}
}
--------------------------------------------------------------------------
package Week02.day0717;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class StackQueueEx {

	public static void main(String[] args) {
		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()) { //empty : stack 이 콜렉션 나오기전 자료구조라 empty를 씀.
			System.out.println(st.pop());
		}
		
		System.out.println("=Queue=");
		while(!q.isEmpty()){ //isEmpty 
			System.out.println(q.poll());
		}
	}
	
	//출력값.
	/*=Stack=
	2
	1
	0
	=Queue=
	0
	1
	2
	 */

}

--------------------------------------------------------------------------
package Week02.day0717;

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); // 앞으로 과제할대 arraylist 써라.
		
		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();
			}
			
			System.out.println("=Original에서 copy2로 이동(move) = ");
			System.out.println("origianl: " + original);
			System.out.println("copy2: " + copy2);
			System.out.println();
		} //main
		
		//출력값.
		/*=Original에서 copy1로 복사(copy) = 
original: [0]
copy1:[0]

=Original에서 copy2로 이동(move) = 
origianl: []
copy2: [0]

=Original에서 copy1로 복사(copy) = 
original: [1]
copy1:[0, 1]

=Original에서 copy2로 이동(move) = 
origianl: []
copy2: [0, 1]

=Original에서 copy1로 복사(copy) = 
original: [2]
copy1:[0, 1, 2]

=Original에서 copy2로 이동(move) = 
origianl: []
copy2: [0, 1, 2]

=Original에서 copy1로 복사(copy) = 
original: [3]
copy1:[0, 1, 2, 3]

=Original에서 copy2로 이동(move) = 
origianl: []
copy2: [0, 1, 2, 3]

=Original에서 copy1로 복사(copy) = 
original: [4]
copy1:[0, 1, 2, 3, 4]

=Original에서 copy2로 이동(move) = 
origianl: []
copy2: [0, 1, 2, 3, 4]

=Original에서 copy1로 복사(copy) = 
original: [5]
copy1:[0, 1, 2, 3, 4, 5]

=Original에서 copy2로 이동(move) = 
origianl: []
copy2: [0, 1, 2, 3, 4, 5]

=Original에서 copy1로 복사(copy) = 
original: [6]
copy1:[0, 1, 2, 3, 4, 5, 6]

=Original에서 copy2로 이동(move) = 
origianl: []
copy2: [0, 1, 2, 3, 4, 5, 6]

=Original에서 copy1로 복사(copy) = 
original: [7]
copy1:[0, 1, 2, 3, 4, 5, 6, 7]

=Original에서 copy2로 이동(move) = 
origianl: []
copy2: [0, 1, 2, 3, 4, 5, 6, 7]

=Original에서 copy1로 복사(copy) = 
original: [8]
copy1:[0, 1, 2, 3, 4, 5, 6, 7, 8]

=Original에서 copy2로 이동(move) = 
origianl: []
copy2: [0, 1, 2, 3, 4, 5, 6, 7, 8]

=Original에서 copy1로 복사(copy) = 
original: [9]
copy1:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=Original에서 copy2로 이동(move) = 
origianl: []
copy2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
		 * 
		 */
	}
}

--------------------------------------------------------------------------

package Week02.day0717;

import java.util.ArrayList;
import java.util.ListIterator;

public class ListIteratorEx1 {

	public static void main(String[] args) {
		
		ArrayList list = new ArrayList();
		list.add("1");
		list.add("2");
		list.add("3");
		list.add("4");
		list.add("5");
		
		ListIterator it = list.listIterator();
		
		while(it.hasNext()) {
			System.out.println(it.next()); // 순방향으로 진행하면서 읽어온다. 1 2 3 4 5 
		}
		System.out.println();
		
		while(it.hasPrevious()) {
			System.out.println(it.previous()); // 역방향으로 진행하면서 읽어온다. 5 4 3 2 1 
		}
		System.out.println();
	}
}

--------------------------------------------------------------------------
package Week02.day0717;

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

public class ArraysExTest {

	public static void main(String[] args) {
		
		//Arrays : 배열을 다루는데 유용한 메소드 정의
		
		/*1. copyof(arr, 갯수) : 배열전체 복사
		 * copyOfRanghe(arr, sPos, ePos) : 배열부분복사, sPos<=x<ePos
		 */
		
		int[] arr = {0, 1, 2, 3, 4};
		int[] arr2 = Arrays.copyOf(arr, arr.length); // 갯수만큼 복사
		int[] arr3 = Arrays.copyOfRange(arr2, 2, 4); // 2,3
		
		/*2. fill(arr, value) : value로 배열 채움
		 */
		
		int[] arr4 = new int[5];
		Arrays.fill(arr4, 9); //9,9,9,9,9
		
		/*3. sort(arr) : 정렬
		 * binarySearch(arr,value) : 지정요소 검색
		 * 정렬을 해야만 올바른 결과
		 */
		
		int[] arr5 = {3, 2, 0, 1, 4};
		Arrays.sort(arr5); // 0,1,2,3,4
		int idx = Arrays.binarySearch(arr5, 2); 
		System.out.println(idx); //2
		
		/*4. equals(arr, arr2): 모든요소비교
		 * toString(): 모든요소출력, 1차원만
		 * deepToString(): 다차원배열 출력
		 */
		
		int[] arr6 = {0, 1, 2, 3, 4};
		int[][] arr7 = {{11,12}, {21,22}};
		System.out.println(Arrays.toString(arr6)); // [0, 1, 2, 3, 4]
		System.out.println(Arrays.deepToString(arr7)); // [[11, 12], [21, 22]]
		
		/*5. asList(Object... a)
		 * 배열을 List로 변환
		 */
		//변경만 가능하고 추가/삭제가 불가능한 List반환
		List list = Arrays.asList(new Integer[] {1,2,3,4,5});
		//추가/삭제 가능하게 하려면 아래처럼
		List list2 = new ArrayList(Arrays.asList(1,2,3,4,5));
		System.out.println(list); // [1, 2, 3, 4, 5]
		System.out.println(list2); // [1, 2, 3, 4, 5]
		

	}

}

--------------------------------------------------------------------------
package Week02.day0717;

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

public class ComparatorEx {

	public static void main(String[] args) {
		String[] strArr = {"cat", "Dog", "lion", "tiger"};
		
		Arrays.sort(strArr); //String의 Comparable구현에 의한 정렬
		System.out.println("strArr=" + Arrays.toString(strArr)); // strArr=[Dog, cat, lion, tiger]
		Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER); // 대소문자 구분안함
		System.out.println("strArr=" + Arrays.toString(strArr)); // strArr=[cat, Dog, lion, tiger]
		
		Arrays.sort(strArr, new Descending());
		System.out.println("strArr=" + Arrays.toString(strArr)); // strArr=[tiger, lion, cat, Dog]

	}
}

class Descending implements Comparator{
	public int compare(Object o1, Object o2) {
		if(o1 instanceof Comparable && o2 instanceof Comparable) {
			Comparable c1 = (Comparable)o1;
			Comparable c2 = (Comparable)o2;
			return c1.compareTo(c2)*-1; // -1을 곱해서 기본 정렬방식의 역으로 변경한다.
										// 또는 c2.compareTo(c1)와 같이 순서를 바꿔도 된다.
		}
		return -1;
	}
}

--------------------------------------------------------------------------

package Week02.day0717;

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

public class HashSetEx1 {

	public static void main(String[] args) {
		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++) {
			set.add(objArr[i]); //HashSet에 objArr의 요소들을 저장한다.
		}
		// HashSet에 저장된 요소들을 출력한다.
		System.out.println(set); // [1, 1, 2, 3, 4]
	}
}

--------------------------------------------------------------------------

package Week02.day0717;

import java.util.LinkedList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class HashSetLotto {

	public static void main(String[] args) {
		
		//로또번호 출력.
		
		Set set = new HashSet();
		
		for(int i=0; set.size()<6; i++) {
			int num = (int)(Math.random()*45)+1;
			set.add(new Integer(num));
		}
		
		List list = new LinkedList(set); // LinkedList(Collection c)
		Collections.sort(list);  // Collections.sort(List list)
		System.out.println(list);
	}
}
--------------------------------------------------------------------------

package Week02.day0717;

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

public class HashSetEx4 {

	public static void main(String[] args) {
		HashSet set = new HashSet();
		set.add(new String("abc"));
		set.add(new String("abc"));
		set.add(new Person2("David", 10));
		set.add(new Person2("David", 10));

		System.out.println(set); // [David:10, abc]
	}
}

//Equals와 hashCode를 하나라도 재정의하지 않으면 중복저장됨.

class Person2{
	String name;
	int age;
	
	Person2(String name, int age){
		this.name = name;
		this.age = age;
	}
	
	public boolean equals(Object obj) { // ★★★ 없으면 중복저장됨.
		if(obj instanceof Person2) {
			Person2 tmp = (Person2)obj;
			return name.equals(tmp.name) && age == tmp.age;
		}
		return false;
	}
	
	public int hashCode() {
		return Objects.hash(name, age); // 속성값을 넣으면 유일한 hash값을 리턴. ★★★ 없으면 중복저장됨.
	}
	
	public String toString() {
		return name + ":" + age;
	}
}

--------------------------------------------------------------------------

package Week02.day0717;

import java.util.Comparator;
import java.util.SortedSet;
import java.util.TreeSet;

public class TreeSetTest {

	public static void main(String[] args) {
		
		/*TreeSet원소는 반드시 Comparable이어야 한다.
		 * TreeSet사용하려면 집합에 들어가는 원소가 comparable을 구현하는 유형이어야 한다.
		 * Comparator를 인자로 받아 들이는 Treeset의 오버로드된 생성자를 사용
		 */
		new TreeSetTest().go();
	}
	
	public void go() {
		//Comparable 이용
		Book b1 = new Book("How Cats Work");
		Book b2 = new Book("Remix your Body");
		Book b3 = new Book("Finding Emo");
		
		TreeSet tree = new TreeSet();
		tree.add(b1);
		tree.add(b2);
		tree.add(b3);
		//정렬되어 조회된다.
		System.out.println("1 : " + tree); // 1 : [Finding Emo, How Cats Work, Remix your Body]
		
		//Comparator이용
		Book2 t1 = new Book2("How Cats Work");
		Book2 t2 = new Book2("Remix your Body");
		Book2 t3 = new Book2("Finding Emo");
		
		TreeSet tree2 = new TreeSet(new BookCompare()); // Comparator를 설정.
		tree2.add(t1);
		tree2.add(t2);
		tree2.add(t3);
		//정렬되어 조회된다.
		System.out.println("2 : "+ tree2); // 2 : [Finding Emo, How Cats Work, Remix your Body]
		//첫번째 값 조회
		System.out.println("3 : "+ tree2.first()); // 3 : Finding Emo
		//마지막값 조회
		System.out.println("4 : "+ tree2.last()); // 4 : Remix your Body
		//삭제
		System.out.println("5 : " + tree2.remove(new Book2("Finding Emo"))); // 5 : true
		System.out.println("6 : " + tree2); // 6 : [How Cats Work, Remix your Body]
		tree2.add(t3);
		
		//인자보다 값이 작은 항목들의 집함
		SortedSet ss = tree2.headSet(new Book2("Remix your Body"));
		System.out.println("7 : " + ss); // 7 : [Finding Emo, How Cats Work]
		//인자보다 값이 크거나 같은 항목들의 집합
		SortedSet ss2 = tree2.tailSet(new Book2("Finding Emo"));
		System.out.println("8 : " + ss2); // 8 : [Finding Emo, How Cats Work, Remix your Body]
		// subSet(a,b) a이상 ~ b미만 인 집함
		SortedSet ss3 = tree2.subSet(new Book2("Finding Emo"), new Book2("Remix your Body"));
		System.out.println("9 : " + ss3); // 9 : [Finding Emo, How Cats Work]
		
		TreeSet tree3 = (TreeSet) tree2.clone();
		System.out.println("10 : " + tree3); // 10 : [Finding Emo, How Cats Work, Remix your Body]
	}
}

class Book implements Comparable{
	private String title;
	
	public Book(String t) {
		title = t;
	}
	
	public String getTitle() {
		return title;
	}
	
	public String toString() {
		return title;
	}
	
	public int compareTo(Object obj) {
		Book book = (Book)obj;
		return title.compareTo(book.getTitle());
	}
}

class Book2{
	private String title;
	
	public Book2(String t) {
		title = t;
	}
	
	public String getTitle() {
		return title;
	}
	
	public String toString() {
		return title;
	}
}

//Comparator에 equals메소드도 존재하지만 재정의하라고 안뜨는건
//Object class에 equals메소드가 구현되어 있기 때문

class BookCompare implements Comparator{
	public int compare(Object arg0, Object arg1) {
		return ((Book2)arg0).getTitle().compareTo(((Book2)arg1).getTitle());
	}
}
--------------------------------------------------------------------------

package Week02.day0717;

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 HashMapEx2 {

	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));
		
		Set set = map.entrySet(); //map entry타입의 콜렉션들을 set형태로 리턴.(set은 유일성을 만족)
		Iterator it = set.iterator();
		while(it.hasNext()) {
			Map.Entry e = (Map.Entry)it.next();
			System.out.println("이름 : " + e.getKey() +", 점수 : " + e.getValue()); //map에는 key와 value가 있다.(map의 기본속성)
			/*이름 : 안자바, 점수 : 90
			이름 : 김자바, 점수 : 100
			이름 : 강자바, 점수 : 80
			이름 : 이자바, 점수 : 100
			 */
		}
		set = map.keySet(); // key만 리턴. 중복불가.
		System.out.println("참가자 명단 : " + set); // 참가자 명단 : [안자바, 김자바, 강자바, 이자바]
		
		Collection values = map.values(); // values만 리턴. 중복가능
		it = values.iterator();
		
		int total = 0;
		while(it.hasNext()) {
			Integer i = (Integer)it.next();
			total+= i.intValue();
		}
		System.out.println("총점 : " + total); // 총점 : 370
		System.out.println("평균 : " + (float)total/set.size()); // 평균 : 92.5
		System.out.println("최고점수 : " + Collections.max(values));  // 최고점수 : 100
		System.out.println("최저점수 : " + Collections.min(values)); // 최저점수 : 80
	}
}

--------------------------------------------------------------------------

package Week02.day0717;

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

public class HashMapEx3 {
	
	static HashMap phoneBook = new HashMap();

	public static void main(String[] args) {
		addPhoneNo("친구", "이자바", "010-111-1111");
		addPhoneNo("친구", "김자바", "010-211-1111");
		addPhoneNo("친구", "박자바", "010-311-1111");
		addPhoneNo("회사", "김대리", "010-411-1111");
		addPhoneNo("회사", "이대리", "010-511-1111");
		addPhoneNo("회사", "박대리", "010-611-1111");
		addPhoneNo("회사", "이과장", "010-711-1111");
		addPhoneNo("세탁", "010-811-1111");
		printList();
	} // main
	
	//그룹을 추가하는 메소드
	static void addGroup(String groupName) {
		if(!phoneBook.containsKey(groupName))
			phoneBook.put(groupName, new HashMap()); // value에 hashmap을 넣음.
	}
	
	//그룹에 전화번호를 추가하는 메소드
	static void addPhoneNo(String groupName, String name, String tel) {
		addGroup(groupName);
		HashMap group = (HashMap)phoneBook.get(groupName);
		group.put(tel, name); //이름은 중복될수 있으니 전화번호를 key로 저장한다.
	}
	
	static void addPhoneNo(String name, String tel) {
		addPhoneNo("기타", name, tel);
	}
	
	//전화번호부 전체를 출력하는 메소드
	static void printList() {
		Set set = phoneBook.entrySet();
		Iterator it = set.iterator();
		
		while(it.hasNext()) {
			Map.Entry e = (Map.Entry)it.next();
			
			Set subSet = ((HashMap)e.getValue()).entrySet();
			Iterator subIt = subSet.iterator();
			
			System.out.println(" * " + e.getKey()+ "[" + subSet.size()+"]");
			
			while(subIt.hasNext()) {
				Map.Entry subE = (Map.Entry)subIt.next();
				String telNo = (String)subE.getKey();
				String name = (String)subE.getValue();
				System.out.println(name = " " + telNo);
			}
			System.out.println();
		}
	} //prinList()
} // class


//출력값
/* 기타[1]
 010-811-1111

 * 친구[3]
 010-111-1111
 010-211-1111
 010-311-1111

 * 회사[4]
 010-611-1111
 010-511-1111
 010-711-1111
 010-411-1111
 */
 
 --------------------------------------------------------------------------
 
 package Week02.day0717;

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

public class HashMapEx4 {

	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])) {
				Integer value = (Integer)map.get(data[i]);
				map.put(data[i], new Integer(value.intValue() + 1));
			} else {
				map.put(data[i], new Integer(1));
			}
		}
		
		Iterator it = map.entrySet().iterator();

		while(it.hasNext()) {
			Map.Entry entry = (Map.Entry)it.next();
			int value = ((Integer)entry.getValue()).intValue();
			System.out.println(entry.getKey() + ": " + printBar('#', value) + " " + value);
		}
	}// main
	
	public static String printBar(char ch, int value) {
		char[] bar = new char[value];
		
		for(int i=0; i<bar.length; i++) {
			bar[i] = ch;
		}
		return new String(bar); //String(char[] chArr)
	}
}

/*출력값
 * 	A: ### 3
	D: ## 2
	Z: # 1
	K: ###### 6
 */ 

--------------------------------------------------------------------------

package Week02.day0717;

import java.util.HashSet;

public class SetTest {

	public static void main(String[] args) {
		HashSet set1 = new HashSet();
		set1.add("phone");
		set1.add("banana");
		System.out.println(set1.add("apple")); // true
		System.out.println("set1: " + set1); // set1: [banana, apple, phone]
		System.out.println("contains: " + set1.contains("apple")); // contains: true
		//추가, 삭제
		HashSet set2 = (HashSet)set1.clone();
		set2.add("melon");
		set2.remove("apple");
		System.out.println("set2 : " + set2); // set2 : [banana, melon, phone]
		//합집합, Collection Add, 중복되지 않게 set2의 내용을 result에 add시킨다.
		HashSet result = (HashSet)set1.clone();
		result.addAll(set2);
		System.out.println("addAll : " + result); // addAll : [banana, apple, melon, phone]
		// 교집합, result값들 중 set2에 있는 값만 남긴다.
		result = (HashSet)set1.clone();
		System.out.println("result : " + result); // result : [banana, apple, phone]
		result.retainAll(set2);
		System.out.println("retainsAll : " + result); // retainsAll : [banana, phone]
		//차집합, result값들 중 set2에 있는 값을 제거한다.
		result = (HashSet)set1.clone();
		result.removeAll(set2);
		System.out.println("removeAll : " + result); // removeAll : [apple]
	}
}