JAVA Programming

2024.05.30. THU <D + 9> ~
2024.05.30. FRI <D + 10> ~
Collection FrameWork (컬렉션 프레임워크)
Collection - 데이터의 집합, 그룹 / FrameWork - 표준화된 프로그래밍 방식
=> 데이터 집합을 저장하는 클래스들을 표준화한 설계

• Collection : 데이터의 집합, 자바에서 모든 컬렉션 클래스와 인터페이스를 포함.
• Collections: Collection 집합 안에 들어있는 여러가지 클래스들.
  ** 핵심 페이스의 종류
  Collection : List와 Set의 기반임, 컬렉션 클래스에 저장된 데이터를 읽고, 추가, 삭제하는 등의 컬렉션을 다루는데 가장 기본적인 메소드를 정의하고 있음.
  A. List - 순서가 있는 데이터의 집합, 중복을 허용

1. ArrayList & LinkedList

• lnkedList logic

class Node{
		Node next;	// 다음의 Node를 가르키는 정보
					// 단방향 LinkedList임을 알 수 있음. 
		Object obj;
	}

2. ArrayList와 LinkedList 차이점

• 접근시간(읽기): ArrayList가 빠름
• 삭제 : LinkedList가 더 빠름

• Stack: LIFO (Last In First Out)

• 단방향 구조 (위에서 밑으로만)

• Queue: FIFO (First In First Out)

• 단방향 구조 (위에서 밑으로만)

• Deque (Double Ended Queue)

• 양방향 구조 (위에서 아래로, 아래에서 위로 둘 다 가능)

3. Iterator - 컬렉션 프레임워크에서 컬렉션에 저장된 데이터를 읽어오는 방법을 표준화

4. Comparator, Comparable - 컬렉션의 정렬과 관련된 기능.
   4-a. HashSet : 저장 순서를 유지하려고하면 LinkedHashSet을 사용.
   4-b. TreeSet : 이진 검색 트리. 정렬, 검색, 범위 검색에 높은 성능을 보임.
   각 노드에 최대 2개의 노드를 연결할 수 있음.
   + 단점) 노드의 추가와 삭제에 오랜 시간이 걸림.
   4-c. Map: 키(key)와 값(value)의 쌍으로 이루어진 데이터의 집합.
   순서를 유지하지 않고, 값은 중복을 허용하지만, 키 중복을 허용하진 않음.
   (HashMap, TreeMap, HashTable, Properties)
   4-c-1. HashMap
   => 데이터의 저장 형태가 선형 구조로 저장되어있음
   => 탐색방법은 순차 탐색으로 진행, 검색 성능이 좋음.
   4-c-2. TreeMap
   => 데이터의 저장 형태가 이진 구조 (왼쪽, 오른쪽)로 저장되어 있음.
   => 이진 탐색으로 진행, 검색 성능이 좋음.
   4-c-3. Properties
   => Key, value가 String 형태.

B. Collections: Collections(자료 묶음)을 쉽게 사용하기 위해 다양한 기능의 메소드가 정의되어 있는 클래스.
예시 코드 ArrayList, Iterator, ListIterator)

// 1. --------------------ArrayList 사용하기--------------------//
public class ArrayListEx {
	// list에 데이터 저장하기
	public static void add(List list) {
		for (int i = 0; i < 100000; i++) {
			list.add(i + ""); 
			}
	}
	
	public static long access(List list) {
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++ )
			list.get(1);
		long end = System.currentTimeMillis();
		return end - start;
	}
	
	public static void main(String[] args) {
		ArrayList list1 = new ArrayList(5);
		list1.add(1);
		list1.add(2);
		list1.add(3);
		list1.add(4);
		list1.add(5);
		// 정렬하기.
		Collections.sort(list1);
		System.out.println("ArrayList 사용하기 - list1 : " + list1);		
		// 다른 데이터 유형을 저장하기
		list1.add(3 ,"A");
		System.out.println("다른 데이터 유형을 저장하기 - list1: " + list1);
		// 섞어보기
		Collections.shuffle(list1);
		System.out.println("데이터를 랜덤으로 섞기 - list1: " + list1);
		//비교대상 생성하기
		ArrayList al = new ArrayList();
		add(al);
		// ArrayList - LinkedList
		LinkedList ll = new LinkedList();
		add(ll);
		// 탐색시간 확인하기
		System.out.println("LinkedList : " + access(ll));
		System.out.println("ArrayList: " + access(al));
// 2. --------------------Iterator 사용하기--------------------//
		ArrayList list2 = new ArrayList();
		list2.add("1");
		list2.add("2");
		list2.add("3");
		Iterator it = list2.iterator();
		// 표준화된 데이터 탐색이 가능해짐
		while (it.hasNext()) {
			Object obj = it.next();
			System.out.println("표준화된 데이터 탐색: " + obj);
			}
		System.out.println();
// 3. ------- Iterator을 개선한 ListIterator 사용하기 -------//		
		ListIterator lit = list2.listIterator();
		// 순방향 탐색해보기
		while (lit.hasNext()) {
			System.out.println("순방향 탐색: " + lit.next());
		}
		System.out.println();
		// 역방향 탐색해보기
		while (lit.hasPrevious()) {
			System.out.println("역방향 탐색: " + lit.previous());
		}
	} //end of main 	
} // end of class

ex2. 정렬,Comparator, Comparable

//5. ------------------ 정렬 사용하기 ------------------//	
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 -1;
	}
}
//5. ------------------ 정렬 사용하기 ------------------//
public class ComparatorEx {

	public static void main(String[] args) {
// 4. ------- Comparator, Comparable  사용하기 -------//
		int a = 10;
		// 랩퍼 클래스: 기본형 int를 객체로 관리하고 싶은 경우 제공되는 클래스
		Integer ii= new Integer(10); //참조형
		ii.compareTo(ii);
		
// 5. ------------------ 정렬 사용하기 ------------------//	
		String[] strArr = {"cat", "dog", "lion", "tiger" };
		Arrays.sort(strArr);
		System.out.println("strArr = " + Arrays.toString(strArr));
		/** 5.1 내림차순 정렬을 만들어보자
		* 1. Comparator interface 클래스 작성하기.
		*	 Compare 메소드를 내림차순 되도록 재정의하기. 
		* 2. Arrays 에서 제공되는 sort() 중에서 
		* 	 Comparator 타입의 매개변수가 있는 메소드를 선택.
		* 3. 구현된 Comparator 클래스를 이용하여 
		*   sort() 메소드의 매개변수로 적용해서 사용. **/
		Arrays.sort(strArr, new Descending());
		System.out.println("strArr = " + Arrays.toString(strArr));
	}
}

ex3. HashSet, TreeSet, HashMap, TreeMap, Properties

// 9. TreeMap 역순구하기 클래스
class Descending2 implements Comparator {
	@Override
	public int compare(Object o1, Object o2) {
		if (o1 instanceof Map.Entry && o2 instanceof Map.Entry)
		{
			Map.Entry e1 = (Map.Entry)o1;
			Map.Entry e2 = (Map.Entry)o2;
			
			Integer v1 = (int)e1.getValue();
			Integer v2 = (int)e2.getValue();
			
			return v1.compareTo(v2) * -1;
		}
		return -1;
	}
}

public class HashTreeEx {
	public static void main(String[] args) {
		System.out.println("HashMap, HashSet, TreeSet");
		
		//6. HashSet
		Object[] objArr = {"1", new Integer(1),"2","2","3","3","4" };
		Set set = new HashSet();
		for (int i = 0; i < objArr.length; i++) {
			set.add(objArr[i]);
		}
		System.out.println("HashSet: " + set);
		
		//7. TreeSet
		Set treeSet = new TreeSet();
		for (int i = 0; treeSet.size() < 6; i++) {
			int num = (int)(Math.random()*45) + 1;
			treeSet.add(num);
		}
		System.out.println("TreeSet: " + treeSet);
		
		//8. HastMap - 데이터 탐색하기.
		System.out.println();
		System.out.println("HastMap - 데이터 탐색하기.");
		HashMap map = new HashMap();
		map.put("myId", "1234");
		map.put("asdf", "1111");
		String id = "myId";
		String password = "1234";
		if (! map.containsKey(id)) {
			System.out.println("입력된 ID는 존재하지 않음");
		} else {
			if (!(map.get(id).equals(password))) {
				System.out.println("비밀번호 불일지");
			} else {
				System.out.println("id와 비밀번호가 일치함.");
			}
		}
		
		
		//HashMap - HashMap을 통해서 Iterator 사용하기
		System.out.println();
		System.out.println("HashMap - HashMap을 통해서 Iterator 사용하기");
		HashMap map2 = new HashMap();
		/**90은 정수 상수, 90을 Object로 UpCasting 해야 함
		 * 자동 형변환: 크기가 작은 자료형에서 크기가 큰 자료형으로 형변환 되는 것,
		 * 그러면 90은 Integer가 되고,
		 * Integer은 int도 객체로 사용하고 싶은 경우에 사용한다.
		 * Integer도 클래스이기 때문에, 자동으로 Object를 상속 받게 된다. **/
		map2.put("이자바", 100);
		map2.put("김자바", 90);
	 	map2.put("박자바", 80);
	 	map2.put("홍자바", 70);
	 	map2.put("안자바", 60);
	 	// Iterator를 사용하기 위해서 Set을 정의하고 Set에서 Iterator가져오기
	 	Set set2= map2.entrySet();
		Iterator it2 = set2.iterator();
		while (it2.hasNext()) {
			Map.Entry entry = (Map.Entry)(it2).next();
			System.out.println("이름 : " + entry.getKey() + " , 점수 : " + entry.getValue());
		}
		
		//+ HashMap에서 value만 출력해보기
		// 점수집합 (총합계산용), 학생집합 (학생명수 사용용)
		// 총점과 평균 계산해보기.
		Collection values = map2.values();
		it2 = values.iterator();
		int total = 0;
		while(it2.hasNext()) {
			Integer grade = (Integer)it2.next(); //Down casting
			total += grade.intValue(); // 점수만을 출력
		}
		System.out.println("점수: " + values + "총점: " + total);
		// 학생 집합을 처리해보자.
		set = map2.keySet();
		System.out.println("학생명부 : " + set);
		// set.size()를 사용하여 평균을 구해보자. 
		System.out.println("평균: " + (float)total/set.size());
		// 최고점수(Collections.max), 최하점수 구해보기(Collections.min)
		System.out.println("최고점수: " + Collections.max(values));
		System.out.println("최하점수: " + Collections.min(values));
		
		// TreeMap 사용해 빈도수의 결과를 구해보기. 
		String[] data = {"A","K","A","K","D","K","A","Z","K","K","Z","D"};
		TreeMap treeMap = new TreeMap();
		TreeMap treeMap2 = new TreeMap(); //TreeMap에 문자 저장하기
		for(int i = 0; i <data.length; i++) {
			// 배열의 문자가 map의 Key로 존재하는지 확인하기 위한 if문
			if(treeMap2.containsKey(data[i])) {
				//빈도수 증가를 위해 현재의 빈도수를 조회
				Integer value = (Integer)treeMap2.get(data[i]);
				//현재의 빈도수 +1 한 값을 해당하는 key에 저장
				treeMap2.put(data[i], value + 1);
			}else {
				//treeMap2의 키로 등록
				treeMap2.put(data[i], 1);
			}
		}
		// 출력을 위한 iterator 생성하기
		Iterator it3 = treeMap2.entrySet().iterator();
		while (it3.hasNext()) {
			Map.Entry entry = (Map.Entry)(it3).next();
			int value = (int)entry.getValue();
			System.out.println(entry.getKey() + " : " + entry.getValue());
			}
		System.out.println("역순정렬");
		// TreeMap을 사용하여 구한 빈도수를 역순으로 출력해보자.
		Set set3 = treeMap2.entrySet();
		List list = new ArrayList(set3);
		
		Collections.sort(list, new Descending2());
		
		it3 = list.iterator();
		while(it3.hasNext()) {
			Map.Entry entry = (Map.Entry)it3.next();
			System.out.println(entry.getKey() + " : " + entry.getValue());
		}
		
		// 10.  Properties 사용해보기.
		Properties prop = new Properties();
		prop.setProperty("size", "10");
		prop.setProperty("capacity", "20");
		prop.setProperty("timeout", "30");
		
		Enumeration e = prop.propertyNames();
		while (e.hasMoreElements()) {
			String element = (String)e.nextElement();
			System.out.println ("element : " + element + " - " + prop.getProperty(element));
		}
		
		}//end of main
	} // end of class