Part21 - collection_framework

/*
컬렉션 프레임워크 (Collection Framework)

    1. 데이터를 다루기 위한 표준화된 구조
    2. 핵심 구조
          <Collectio>
          * List      - ArrayList        * 부모<타입> 객체명 = new 자식<>();
          (parent)    - LinkedList         자식<타입> 객체명 = new 자식<>();
                      - Vector
          * Set       - HashSet
          (parent)
          * Map       - HashMap
          (parent)    - SortedMap    - TreeMap
                      - Hashtable
							
    3. 주요 인터페이스의 핵심 기능
        1) List
            (1) 순서가 있는 데이터의 집합
            (2) 중복 저장 허용
        2) Set
            (1) 순서가 없는 데이터의 집합
            (2) 중복 저장 불가
        3) Map
            (1) 키(key)와 값(value)의 쌍(pair)으로 이루어진 데이터
            (2) 순서가 없는 데이터의 집합
            (3) 키(key)는 중복 저장 불가
            (4) 값(value)는 중복 저장 허용
			
    4. 반복자 (Iterator) 를 사용할 수 있다.
        List<String> list = new ArrayList<>();
        Iterator itr = list.iterator();    // itr : 컬렉션의 요소를 꺼낼 수 있다.
        while(itr.hasNext()){
            itr.next();
        }
        
ArrayList
    1. 객체(인스턴스)를 여러 개 저장할 수 있는 "배열"을 구현한 컬렉션이다.
    2. 가장 많이 사용된다.
    3. 기존에는 Vector 를 많이 사용했다.
    4. 장점
        (1) 구조가 단순하다.
        (2) 읽어들이는 속도가 빠르다.
        (3) 저장된 객체들의 변화가 적은 경우에 사용하면 좋다.		
    5. 단점
        (1) 일단 만들고 나면 나중에 크기 변경이 힘들다.
        (2) 처음부터 크게 만들면 공간 낭비가 생긴다.
        (3) 비순차적 접근이 느리다.
        (4) 데이터의 중간 위치에 추가/제거가 어렵다.
		
LinkedList
    1. 자신과 연결된 다음 요소에 대한 참조 + 데이터로 구성된다.
    2. 비연속적인 공간을 사용한다.
    3. 장점
        1) 추가 / 삭제 작업이 빠르다.
        2) 잦은 추가 / 삭제가 발생되는 경우에 사용한다.
    4. 단점
        1) 순차적인 순회가 느리다.
        2) 구현이 어렵고, 오류가 발생할 가능성이 있다.
		
HashSet
    1. Set 인터페이스를 구현한 대표적인 클래스이다.
    2. 중복된 데이터는 저장되지 않는다.
    3. 중복된 데이터 판단 원리
        1) hashCode() 확인
            (1) 값이 같으면 equals() 호출해서 동등 비교
            (2) 값이 다르면 다른 데이터로 판단
        2) equals() 확인
    4. 사용자가 정의한 객체(인스턴스)를 저장하려면 hashCode(), equals() 오버라이드 해야 한다.
    5. 저장 순서가 없다. (add 한 순서대로 유지되지 않는다.)
    6. 순서를 유지하려면 LinkedHashSet 클래스를 사용한다. ***중요

HashMap
    1. 해시코드를 사용하는 Map 이다. (많은 양의 자료에 적합)
    2. 키(key) + 값(value)의 조합으로 데이터를 저장한다.
*/

Ex01_ArrayList

package com.mywork.ex;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Ex01_ArrayList {

	public static void main(String[] args) {
		
		List<Integer> list = new ArrayList<>();
		
		// 1. 저장 : add
		list.add(new Integer(1));
		list.add(new Integer(2));
		list.add(5);	// Auto Boxing 에 의해서 가능한 코드! (Refer 클래스라서 가능)
		list.add(4);
		list.add(3);
		
		// 2. 저장된 요소 가져오기 : get
		System.out.println("첫 번째 요소 : " + list.get(0));		
		System.out.println("두 번째 요소 : " + list.get(1));
		
		// 3. 크기 : size	--> 순서대로 순회할때 쓸 수 있다.
		for(int i = 0; i < list.size(); i++) {	// length -> size()로 대체
			System.out.println(list.get(i));
		}
		
		// 4. 삭제 : remove
		list.remove(0);		// 0번 인덱스의 데이터 삭제
		
		// 5. 확인 (저장 유무 확인) : contains(객체) 두개의 비교대상이 있어야 한다. <obj1.contains(obj2)>
		List<Integer> list2 = new ArrayList<>();
		list2.add(new Integer(5));
		list2.add(new Integer(6));
		list2.add(new Integer(7));
		
		for(int i = 0; i < list2.size(); i++) {
			if(list.contains(list2.get(i))) {
				System.out.println(list2.get(i));
			}
		}	
		// 6. 컬렉션은 그냥 출력해도 된다.
				System.out.println("list = " + list);
				
		// 7. 정렬할 수도 있다.
				Collections.sort(list);
				System.out.println("정렬 후 list = " + list);
		
		// 8. 최악의 성능이 나타나도록 list 의 모든 데이터를 삭제하시오.
		while(list.size() > 0) {
			list.remove(0);				  // 최악
//			list.remove(list.size() - 1); // 최고
		}
		
	}

}

Ex02_Iterator

package com.mywork.ex;

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

public class Ex02_Iterator {
	public static void main(String[] args) {
		
		List<Integer> list = new ArrayList<>();
		// 10, 20, 30, , , 100
		for(int i = 0; i < 10; i++) {
			list.add((i + 1) * 10);
		}
		
		// 반복자를 통한 list 순회
		Iterator<Integer> itr = list.iterator();
		
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
		
	}

}

Ex03_LinkedList

package com.mywork.ex;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class Ex03_LinkedList {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		List<String> list = new LinkedList<String>();
		// 이름을 3개 입력 받아 LinkedList에 저장하고 순회하기
		
		for(int i = 0; i < 3; i++) {
			System.out.print("이름 >> ");
			String name = scanner.next();
			list.add(name);
		}
		for(int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		scanner.close();
	}

}

Ex04_HashSet

package com.mywork.ex;

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

public class Ex04_HashSet {
	public static void main(String[] args) {
		Set<String> set = new HashSet<String>();
		
		set.add("C");
		set.add("Java");
		set.add("DB");
		set.add("JSP");
		set.add("Web");
		set.add("Spring");
		set.add("Java");		// 중복 저장 시도
		
		Iterator<String> itr = set.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}

}

Ex05_HashSet

package com.mywork.ex;

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

class User{
	
	// Field
	private String id;
	private String pw;
	
	// Constructor
	public User(String id, String pw) {
		this.id = id;
		this.pw = pw;
	}
	
	// Method
	@Override
	public String toString() {
		return "아이디 : " + id;
	}
	@Override
	public int hashCode() {
		// return 1;                ID의 모든 문자 다 비교
		// return id.length();      ID의 문자의 길이로 비교
		// return id.charAt(0);     ID의 문자열의 첫번째 문자로 비교
		return id.charAt(0) + pw.length();	
	}
	@Override
	public boolean equals(Object obj) {
		if(obj != null && obj instanceof User) {
			String otherId = ((User)obj).id;
			return id.equals(otherId);
		}else{
			return false;
		}
	}
	
}

public class Ex05_HashSet {

	public static void main(String[] args) {
		Set<User> set = new HashSet<User>();
		
		set.add(new User("admin", "1234"));
		set.add(new User("admin", "1234"));
		
		Iterator<User> itr = set.iterator();
		
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}

}

Ex06_HashMap

package com.mywork.ex;

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

public class Ex06_HashMap {

	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<String, Integer>();
		
		// 데이터 추가 : put(key, value)
		map.put("alice", 20);
		map.put("james", 20);
		map.put("tom", 25);
		map.put("alice", 21);  // key 중복 발생(alice)!
		                       // 중복된 key 를 삽입하려고 하면, 기존 value 를 최근에 저장한 값으로 대체한다.
		
		// 삭제 : remove(key)
		map.remove("tom");
		
		// 반복자는 key 를 통해 순회한다!
		// map 에서 key 만 추출하여 순회한다!
		// map 의 key 를 Set 에 저장한다!
		Set<String> set = map.keySet();
		Iterator<String> itr = set.iterator();
		
		// 저장된 value 가져오기 : get(key)
		while(itr.hasNext()) {
			String key = itr.next();
			Integer value = map.get(key);
			System.out.println("키 : " + key + ", 값 : " + value);
		}
		
		// itr 을 순회하고 나면 그 itr 은 사용할 수 없다!
		// 새로 itr 값을 받아서 사용해야 한다.
		itr = set.iterator();	// 다시 정보를 얻어 옴!
		while(itr.hasNext()) {
			String key = itr.next();
			Integer value = map.get(key);
			System.out.println("키 : " + key + ", 값 : " + value);
		}
		
		// 크기 : size()
		System.out.println("entry 개수 : " + map.size());
		
		// iteratorUsingForEach
//		Set<Map.Entry<String, Integer>> entries = map.entrySet();
//		for(Map.Entry<String, Integer> entry : entries) {
//			System.out.println(entry.getKey() + " : " + entry.getValue());
//		}
		
		// iteratorUsingIterator
		Set<Map.Entry<String, Integer>> entries = map.entrySet();
		Iterator<Map.Entry<String, Integer>> i = entries.iterator();
		while(i.hasNext()) {
			Map.Entry<String, Integer> entry = i.next();
			System.out.println(entry.getKey() + " : " + entry.getValue());
		}
		
		
	}

}