169 - Java 컬렉션(Collection) : Set - TreeSet 클래스, 자동적으로 오름차순 정렬을 실행하는 클래스이다. 중복을 허용하지 않고 순서가 없다.

/* ====================================
  ■■■ 컬렉션 (Collection) ■■■
======================================*/

// Set → HashSet, TreeSet, ...
// · 순서 없음
// · 중복 허용하지 않는 구조(기본)

/*
정렬은 부하가 많이 걸리는 작업이므로
성능이 떨어지는 클래스임을 알 수 있다.


○ TreeSet<E> 클래스

   java.util.TreeSet<E> 클래스는
   Set 인터페이스를 상속한 SortedSet 인터페이스를 구현한 클래스로
   데이터를 추가하면 데이터들이 자동으로 오름차순 정렬이 된다.
*/


// VO	- Value Ovject
// DTO	- Data Transfer Object
// DAO	- Data Access Object



// ↓ 실무에서 주로 사용하는 것
// DTO	- Data Transfer Object
// DAO	- Data Access Object

// VO DTO 비슷한 계층이다.
// 업무 로직에 따라 구분한다...
 
// VO 계층으로도 사용
// DAO

import java.util.Iterator;
import java.util.TreeSet;
import java.util.Comparator;


class GradeVO
{
	// 주요 속성 구성
	private String hak;			//-- 학번
	private String name;		//-- 이름
	private int kor, eng, mat;	//-- 국어, 영어, 수학 점수

	
	// 사용자 정의 생성자 → 5개의 매개변수를 가진 생성자
	GradeVO(String hak, String name, int kor, int eng, int mat)
	{
		this.hak = hak;
		this.name = name;
		this.kor = kor;
		this.eng = eng;
		this.mat = mat;
	}

	// 이와 같은 경우 default 생성자 자동 삽입되지 않음~!!!

	// 사용자 정의 생성자 → 매개변수 없는 생성자(default 생성자 형태)
	GradeVO()
	{
		// 생성자 내부에서 또다른 생성자 호출
		//GradaVO("", "", 0, 0, 0);
		// ↓ 
		this("", "", 0, 0, 0);
	
	}

	// getter / setter 구성


// [getter]===============================

	public String getHak()
	{
		return hak;
	}

	public String getName()
	{
		return name;
	}

	public int getKor()
	{
		return kor;
	}

	public int getEng()
	{
		return eng;
	}

	public int getMat()
	{
		return mat;
	}

// =======================================


// [setter]===============================

	public void setHak(String hak)
	{
		this.hak = hak;
	}

	public void setName(String name)
	{
		this.name = name;
	}

	public void setKor(int kor)
	{
		this.kor = kor;
	}

	public void setEng(int eng)
	{
		this.eng = eng;
	}

	public void setMat(int mat)
	{
		this.mat = mat;
	}
// =======================================

	public int getTot()
	{
		//return kor + eng + mat;
		return this.kor + this.eng + this.mat;
	}

	//@Override
	//public String toString()
	//{
	//	return String.format("학번 : %s  이름 : %s  ");
	//	
	//}


}

// 트리셋이라는 자료구조 자체가 내부에서 정렬을 한다 → 그것이 Compare...
// MyComparator<T> 설계중
// ★ T를 넣으면 어떤 Type을 넘겨 주면... 이라는 의미
// ★ E를 넣으면 어떤 Element를 수용하겠다라는 표현

// Compare라는 메소드를 오버라이딩 하기위해
class MyComparactor<T> implements Comparator<T> 
{
	
	// o1과 o2를 받아왔으면 뭘 반환...

	
	// 비교 메소드 재정의				// T type의 무언가가 매개변수로... 들어온다...	
	@Override							// 사용자가 설정한 타입의 변수가 메소드의 인자로...(사용자가 세팅)
	public int compare(T o1, T o2)
	{
		// 매개변수로 들어온 값들을
		// GradeVO 타입으로 변경하도록
		// 부모 클래스 Comparator의 compare() 메소드를
		// 오버라이딩 하고 있다.

		GradeVO s1 = (GradeVO)o1;
		GradeVO s2 = (GradeVO)o2;

		// compare를 통해 들어온 두 인자 o1, o2를 빼서
		// 음수가 나오면 뒤에 값 o2가 더 큰 것이고
		// 양수가 나오면 앞에 값 o1이 더 큰 것이며
		// 0이 나오면 서로 같다는 원리를 이용하여 compare() 메소드는
		// 문자열 크기를 비교한다.


		// 학번 기준(오름차순)
		//return Integer.parseInt(s1.getHak()) - Integer.parseInt(s2.getHak());

		
		//2308103 김다슬 70 95 91
		//2308113 길현욱 90 80 70
		//2308116 최혜인 91 81 81
		//2308120 이윤수 88 78 68
		//2308132 정현욱 99 82 79
		

		// return Integer.parseInt(s1.getHak()) - Integer.parseInt(s2.getHak());
		// return Integer.parseInt("2308113") - Integer.parseInt("2308116");
		// return 2308113 - 2308116
		// return -3
		// → o2 가 더 큰 것으로 비교 결과 전달~!!!

		// ... return 5;
		// → o1 이 더 큰 것으로 비교 결과 전달~!!!

		// ... return 0;
		// → o1 과 o2 가 같은 것으로 비교 결과 전달~!!!


		// 학번 기준(내림차순)
		//return Integer.parseInt(s2.getHak()) - Integer.parseInt(s1.getHak());
		
		//2308132 정현욱 99 82 79
		//2308120 이윤수 88 78 68
		//2308116 최혜인 91 81 81
		//2308113 길현욱 90 80 70
		//2308103 김다슬 70 95 91
		

		// 총점 기준(오름차순)
		//return s1.getTot() - s2.getTot();

		//2308120 이윤수 88 78 68
		//2308113 길현욱 90 80 70
		//2308116 최혜인 91 81 81
		//2308103 김다슬 70 95 91
		//2308132 정현욱 99 82 79
		

		// 총점 기준(내림차순)
		//return s2.getTot() - s1.getTot();
		
		//2308132 정현욱 99 82 79
		//2308103 김다슬 70 95 91
		//2308116 최혜인 91 81 81
		//2308113 길현욱 90 80 70
		//2308120 이윤수 88 78 68



		// 이름 기준(오름차순)

	

		//return (s1.getName()).compareTo(s2.getName());

		//2308113     길현욱   90   80   70
		//2308103     김다슬   70   95   91
		//2308120     이윤수   88   78   68
		//2308132     정현욱   99   82   79
		//2308116     최혜인   91   81   81
		
		// 이름 기준(내림차순)

		//return (s2.getName()).compareTo(s1.getName());

		//2308116     최혜인   91   81   81
		//2308132     정현욱   99   82   79
		//2308120     이윤수   88   78   68
		//2308103     김다슬   70   95   91
		//2308113     길현욱   90   80   70
		
		int result;

		for (int i = 0; i < 3; i++)
		{	
			만약에 s1의 이름0과 s2의 이름0이 같다면
											 같지 않다면
												비교
													 return a - b;
				만약에 s1의 이름1과 s2의 이름1이 같다면
				  .
				  .
				만약에 s1의 이름s1이름.length()와 
			result += (s1.getName()).charAt(i) - (s2.getName()).charAt(i);
		}



		return result;
		

	}


	
}




public class Test169
{
	public static void main(String[] args)
	{
		// TreeSet 자료구조 생성
		TreeSet<String> set = new TreeSet<String>();

		// TreeSet 자료구조 set 에 요소 추가 → add()
		set.add("짱구는못말려");
		set.add("슬램덩크");
		set.add("원피스");
		set.add("달빛천사");
		set.add("이누야샤");
		set.add("너의이름은");
		set.add("슈가슈가룬");
		set.add("배틀짱");
		set.add("디지몬");
		
		// Iterator 를 활용한 Set 요소 전체 출력

		Iterator<String> it = set.iterator();
		
		System.out.print("전체 요소 출력 : ");
		while (it.hasNext())
		{
			System.out.print(it.next() + " ");
		}
		System.out.println();	// 가나다 오름차순 정렬된 형태로 출력되었다. 넣은 순서 관계 없이
		//--==>> 전체 요소 출력 : 너의이름은 달빛천사 디지몬 배틀짱 슈가슈가룬 슬램덩크 원피스 이누야샤 짱구는못말려
		//-- 요소를 문자열로 구성할 경우
		//   가나다순 → 오름차순 정렬
		

		// TreeSet 자료구조 생성
		//TreeSet<GradeVO> set2 = new TreeSet<GradeVO>();

		TreeSet<GradeVO> set2 = new TreeSet<GradeVO>(new MyComparactor<GradeVO>());

		// TreeSet 자료구조 set2에 요소 추가
		set2.add(new GradeVO("2308113", "길현욱",  90,  80,  70));
		set2.add(new GradeVO("2308116", "최혜인", 91, 81, 81));
		set2.add(new GradeVO("2308120", "이윤수", 88, 78, 68));
		set2.add(new GradeVO("2308103", "김다슬", 70, 95, 91));
		set2.add(new GradeVO("2308132", "정현욱", 99, 82, 79));

		// Iterator 를 활용한 set2 요소 전체 출력
		
		/*
		Iterator<GradeVO> it2 = set2.iterator();
		
		while (it2.hasNext())
		{
			System.out.print(it2.next() + " ");
			
		}
		System.out.println();
		
		//--==>> 에러 발생(런타임 에러)
		//       java.lang.ClassCastException:
		//       GradeVO cannot be cast to java.lang.Comparable
		
		// 크기 비교 기본적으로 문자열로 한다.
		// 트리셋이라는 자료구조 자체가
		// 내부적으로 격납되는 데이터에 대해서
		// 문자열을 기반으로 비교하게끔 만들어 놓은 것이다.
		// 그렇기 때문에 Iterator 로 비교할 수가 없는 것이다.
		// (지금 GradeVO를 제네릭으로 두었기 때문에)
		// 특정한 처리를 하지 않으면 원활하게 사용할 수가 없다.
				↓
		*/
		// ※ MyComparator 클래스를 생성하여
		//    compare() 메소드를 재정의 한 후 다시 구성
		/*
		Iterator<GradeVO> it2 = set2.iterator();

		while (it2.hasNext())
		{
			System.out.print(it2.next() + " ");
		}
		System.out.println();
		*/
		//		↓
		//
		// ※ 객체 자체를 직접 출력하는 것이 아니라
		//    객체가 갖고있는 속성에 접근하여 출력할 수 있도록 처리
		//
		
		
		/*
		for (GradeVO a : set2)
		{
			System.out.printf("%s %s %d %d %d\n", a.getHak(), a.getName(), a.getKor(), a.getEng(), a.getMat());

		}
		System.out.println();
		*/

		Iterator<GradeVO> it2 = set2.iterator();
		while (it2.hasNext())
		{
			// ★☆★☆★☆★☆
			// it2.next() 를 한번 한 후에 또 그 다음으로 넘어가기 때문에
			// GradeVO [0] → GradeVO[1] 이런 식으로 넘어가므로 오류!!
			// 속성이 넘어가도록 처리해 줘야 하기 때문에 제대로 처리되지 않는다.

			//→ System.out.print(it2.next() + " " + it2.next().getName());

			GradeVO vo = it2.next();
			System.out.printf("%7s %7s %4d %4d %4d\n", vo.getHak(), vo.getName(), 
								vo.getKor(), vo.getEng(), vo.getMat());
		}
		System.out.println();
		

	}
}