21. 컬렉션 프레임워크

1. 자료(Data)와 자료구조(Data Structure)
    1) 자료(데이터)를 어디에 어떻게 관리할지
        - 검색, 순회(iterate), 저장, 삭제, 변경 ...
    2) 데이터의 형태와 쓰임에 가장 적합한 자료구조를 사용하는 것이 매우 중요
    3) 자료의 효율적인 관리는 프로그램의 수행속도와 밀접한 관련이 있음

2. 자료구조 종류
    1) 한 줄로 자료를 관리하기 (선형 자료구조)
        - 배열(Array)
        - 연결리스트(LinkedList)
        - 스택(Stack)
        - 큐(Queue)
    2) 트리(tree)
    3) 그래프(graph)
    4) 해싱(hashing)

3. 배열(Array) 구현
    1) 동일한 데이터 타입을 순서에 따라 관리하는 자료 구조
    2) 정해진 크기가 있음
    3) 배열의 i번째 요소를 찾는 인덱스 연산이 빠름
    4) JDK 클래스 : ArrayList, Vector ...

public class MyArray {

	int[] intArr;
	int count;
	
	public int ARRAYSIZE;
	public static final int ERROR_NUM = -999999999;
	
	public MyArray() {
		count = 0;
		ARRAYSIZE = 10;
		intArr = new int[ARRAYSIZE];
	}
	
	public MyArray(int size) {
		count = 0;
		ARRAYSIZE = size;
		intArr = new int[ARRAYSIZE];
	}
	
	public void addElement(int num) {
		if(count >= ARRAYSIZE) {
			System.out.println("not enough memory");
			return;
		}
		
		intArr[count++] = num;
		
	}
	
	// 선형 리스트에서 원소 삽입 -> 그 이후의 원소들은 한 자리씩 자리를 뒤로 이동함
	public void insertElement(int position, int num) {
		if(count >= ARRAYSIZE) {
			System.out.println("not enough memory");
			return;
		}
		
		if(position < 0 || position > count) {
			System.out.println("insert error");
			return;
		}
		
		for(int i = count-1; i>= position; i--) {
			intArr[i+1] = intArr[i];
		}
		
		intArr[position] = num;
		count++;
	}
	
	public boolean isEmpty() {
		if(count == 0) {
			return true;
		}
		else 
			return false;
	}
	
	// 선형 리스트에서의 원소 삭제 -> 그 이후의 원소들은 한 자리씩 자리를 앞으로 이동함
	public int removeElement(int position) {
		int ret = ERROR_NUM;
		
		if(isEmpty()) {
			System.out.println("There is no element");
			return ret;
		}
		
		if(position < 0 || position > count) {
			System.out.println("remove error");
			return ret;
		}
		
		ret = intArr[position];
		
		for(int i = position; i<count-1; i++) {
			intArr[i] = intArr[i+1];
		}
		count--;
		
		return ret;
	}
	
	public int getSize() {
		return count;
	}
	
	public int getElement(int position) {
		
		if(position < 0 || position > count + 1) {
			System.out.println("검색 위치 오류. 현재 리스트의 개수는 " + count + "개 입니다.");
			return ERROR_NUM;
		}
		
		return intArr[position];
	}
	
	public void printAll() {
		if(count == 0) {
			System.out.println("출력할 내용이 없습니다.");
			return;
		}
		for(int i=0; i<count; i++) {
			System.out.println(intArr[i]);
		}
	}
	
	public void removeAll() {
		if(count == 0) {
			System.out.println("삭제할 내용이 없습니다.");
			return;
		}
		for(int i=0; i<count; i++) {
			intArr[i] = 0;
		}
		count = 0;
	}

public class MyArrayTest {

	public static void main(String[] args) {
		MyArray array = new MyArray();
		array.printAll();							// 출력할 내용이 없습니다.
		System.out.println(array.intArr.length);	// 10
		System.out.println(array.getSize());		// 0
		System.out.println();
		
		array.addElement(10);
		array.addElement(20);
		array.addElement(30);
		array.printAll(); 							// 10 20 30
		System.out.println(array.getSize());		// 3
		System.out.println(array.getElement(0));	// 10
		System.out.println(array.getElement(3));	// 0
		System.out.println();
		
		array.insertElement(1, 50);
		array.printAll(); 							// 10 50 20 30
		System.out.println();
		
		array.removeElement(1);
		array.printAll(); 							// 10 20 30
		System.out.println();
		
		array.addElement(70);
		array.printAll(); 							// 10 20 30 70
		System.out.println();
		
		array.removeElement(1);
		array.printAll();							// 10 30 70
		
	}

}

4. 컬렉션 프레임워크
    1) 프로그램 구현에 필요한 자료구조와 알고리즘을 구현해 놓은 라이브러리
    2) java.util 패키지에 구현되어 있음
    3) Collection 인터페이스와 Map 인터페이스로 구성됨

5. Collection 인터페이스 
    1) 하나의 객체의 관리를 위해 선언된 인터페이스 
    2) 하위에 List, Set 인터페이스 
        - List : 순서가 있는 자료 관리, 중복 허용
                 구현 클래스 -- ArrayList, Vector, LinkedList, Stack, Queue
        - Set : 순서가 정해져 있지 않음, 중복을 허용하지 않음
                구현 클래스 -- Hashset, Treeset

import java.util.LinkedList;

public class LinkedListTest {

	public static void main(String[] args) {
		LinkedList<String> myList = new LinkedList<>();
		
		myList.add("A");
		myList.add("B");
		myList.add("C");
		
		System.out.println(myList.toString());	// [A, B, C]
		
		myList.add("D");
		System.out.println(myList);				// [A, B, C, D]
		
		myList.removeLast();
		System.out.println(myList); 			// [A, B, C]
		
		for(int i=0; i<myList.size(); i++) {
			String str = myList.get(i);
			System.out.println(str); 			// A B C
		}
	}
}

import java.util.LinkedList;

public class LinkedListTest02 {

	public static void main(String[] args) {
		
		LinkedList<String> fruitList = new LinkedList<>();
		fruitList.add("사과");
		fruitList.add("바나나");
		fruitList.add("수박");
		fruitList.add(2, "망고");
		
		int position = fruitList.indexOf("수박");
		System.out.println("수박의 위치 : " + position);	// 수박의 위치 : 3
		
		fruitList.add(0, "오렌지");
		String fruit = fruitList.get(0);
		System.out.println("과일이름 : " + fruit);		// 과일이름 : 오렌지
		System.out.println();
		
		int size = fruitList.size();
		System.out.println("연결리스트의 값 출력");
		for(int i = 0; i<size; i++) {
			fruit = fruitList.get(i);
			System.out.println(fruit);		// 오렌지 사과 바나나 망고 수박
		}
	}
}

 

6. Map 인터페이스
    1) 쌍으로 이루어진 객체를 관리하는데 필요한 여러 메서드가 선언되어 있음
    2) Map을 사용하는 객체 key-value쌍으로 되어있고 key는 중복될 수 없음
    3) 구현 클래스 -- HashMap, TreeMap, HashTable, Properties

7. List 인터페이스
    1) 배열의 기능을 구현하기 위한 메서드가 선언됨
    2) ArrayList와 Vector
        - 객체 배열 클래스
        - 일반적으로 ArrayList를 더 많이 사용
        - Vector는 멀티 스레드 프로그래밍에서 동기화를 지원
          (동기화(synchronization) : 두 개의 스레드가 동시에 하나의 리소스에 접근할 때 순서를 맞추어서 데이터의 오류가 방지되도록 함)

public class Board {

	String subject;
	String content;
	String writer;
	
	public Board(String subject, String content, String writer) {
		// super();
		this.subject = subject;
		this.content = content;
		this.writer = writer;
	}
}







import java.util.Iterator;
import java.util.Vector;

public class VectorTest {
	public static void main(String[] args) {
		
		// 용량이 5개인 벡터 생성
		Vector<Board> vector = new Vector<>(5);
		System.out.println("용량 : " + vector.capacity());	// 용량 : 5
		System.out.println("초기 사이즈 : " + vector.size());	// 초기 사이즈 : 0
		System.out.println();
		
		// 객체 추가
		vector.add(new Board("제목1", "내용1", "글쓴이1"));
		vector.add(new Board("제목2", "내용2", "글쓴이2"));
		vector.add(new Board("제목3", "내용3", "글쓴이3"));
		vector.add(new Board("제목4", "내용4", "글쓴이4"));
		vector.add(new Board("제목5", "내용5", "글쓴이5"));
		System.out.println("객체 추가 후 용량 : " + vector.capacity());	// 객체 추가 후 용량 : 5
		System.out.println("객체 추가 후 사이즈 : " + vector.size());		// 객체 추가 후 사이즈 : 5
		System.out.println();
		
		vector.add(new Board("제목1", "내용1", "글쓴이1"));
		vector.add(new Board("제목2", "내용2", "글쓴이2"));
		vector.add(new Board("제목3", "내용3", "글쓴이3"));
		vector.add(new Board("제목4", "내용4", "글쓴이4"));
		vector.add(new Board("제목5", "내용5", "글쓴이5"));
		System.out.println("객체 추가 후 용량 : " + vector.capacity());	// 객체 추가 후 용량 : 10
		System.out.println("객체 추가 후 사이즈 : " + vector.size());		// 객체 추가 후 사이즈 : 10
		System.out.println();
		
		// 객체 삭제
		vector.remove(2);
		vector.remove(3);
		System.out.println("객체 삭제 후 용량 : " + vector.capacity());	// 객체 삭제 후 용량 : 10
		System.out.println("객체 삭제 후 사이즈 : " + vector.size());		// 객체 삭제 후 사이즈 : 8
		System.out.println();
		
		// 용량만 확보
		vector.ensureCapacity(20);
		System.out.println("용량 확보 후 용량 : " + vector.capacity());	// 용량 확보 후 용량 : 20
		System.out.println("용량 확보 후 사이즈 : " + vector.size());		// 용량 확보 후 사이즈 : 8
		System.out.println();
		
		for(Board board : vector) {
			System.out.println(board.subject + board.content + board.writer);
		}
		//		제목1내용1글쓴이1
		//		제목2내용2글쓴이2
		//		제목4내용4글쓴이4
		//		제목1내용1글쓴이1
		//		제목2내용2글쓴이2
		//		제목3내용3글쓴이3
		//		제목4내용4글쓴이4
		//		제목5내용5글쓴이5
		System.out.println();
		
		// 반복자로 출력
		Iterator<Board> iterator = vector.iterator();
		while(iterator.hasNext()) {			// 가져올 데이터가 있는지
			Board board = iterator.next();	// 데이터가 있으면 가져와라
			System.out.println(board.subject + board.content + board.writer);
			// 위와 같은 결과값
		}
	}
}

    3) ArrayList와 LinkedList
        - 자료의 순차적 구조를 구현한 클래스
        - ArrayList는 배열을 구현한 클래스로 논리적 순서와 물리적 순서가 동일함
        - LinkedList는 논리적으로 순차적인 구조지만 물리적으로는 순차적이지 않을 수 있음
            [자료(data) | 다음 노드의 주소]     [자료(data) | 다음 노드의 주소]
    4) Stack
        - LIFO(Last In First Out) : 맨 마지막에 추가된 요소가 가장 먼저 꺼내지는 자료구조
        - 최근 자료 가져오기, 게임에서 최근 저장 불러오기
        - 추가하기 : push, 삭제하기 : pop, 가장 상위의 것 : top
        - ArrayList나 LinkedList로 구현할 수 있음
    5) Queue
        - FIFO(First In Firts Out) : 가장 먼저 저장된 자료가 먼저 꺼내지는 자료구조
        - 선착순, 대기열 등을 구현할 때 가장 많이 사용되는 자료구조
        - ArrayList나 LinkedList로 구현할 수 있음
        - 추가하기 : enqueue, 삭제하기 : dequeue, 맨 앞 : front, 맨 뒤 : rear

import java.util.ArrayList;

class MyStack {
	private ArrayList<String> arrayList = new ArrayList<>();
	
	public void push(String data) {
		arrayList.add(data);
	}
	
	public String pop() {
		int length = arrayList.size();
		
		if(length == 0) {
			System.out.println("스택이 비어있습니다.");
			return null;
		}
		
		return arrayList.remove(length-1);
	}
}

public class StackTest {
	public static void main(String[] args) {
		MyStack stack = new MyStack();
		
		stack.push("A");
		stack.push("B");
		stack.push("C");
		
		System.out.println(stack.pop());	// C
		System.out.println(stack.pop());	// B
		System.out.println(stack.pop());	// A
		System.out.println(stack.pop());	// 스택이 비었습니다. null
	}
}

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

public class StackQueueTest {

	public static void main(String[] args) {
		
		Stack<String> stack = new Stack<>();
		// Queue는 인터페이스를 구현한 LinkedList 클래스 생성 (다형성 적용)
		Queue<String> queue = new LinkedList<>();
		
		// 후입선출(LIFO)
		stack.push("0");
		stack.push("1");
		stack.push("2");
		
		// 선입선출(FIFO)
		queue.offer("0");
		queue.offer("1");
		queue.offer("2");
		
		System.out.println("---스택---");
		while(!stack.isEmpty()) {
			System.out.println(stack.pop());	// 2 1 0
		}
		
		System.out.println("---큐---");
		while(!queue.isEmpty()) {
			System.out.println(queue.poll());	// 0 1 2
		}
		
	}
}

public class Coin {
	
	private int value;
	
	public Coin(int value) {
		this.value = value;
	}
	
	public int getValue() {
		return this.value;
	}
}






public class CoinTest {

	public static void main(String[] args) {
		
		Stack<Coin> coins = new Stack<>();
		coins.push(new Coin(100));
		coins.push(new Coin(10));
		coins.push(new Coin(500));
		coins.push(new Coin(50));
		coins.push(new Coin(700));
		
		while(!coins.isEmpty()) {
			Coin coin = coins.pop();
			System.out.println("꺼내온 동전 : " + coin.getValue());
			/*
			꺼내온 동전 : 700
			꺼내온 동전 : 50
			꺼내온 동전 : 500
			꺼내온 동전 : 10
			꺼내온 동전 : 100
			 */
		}
	}
}

public class Message {
	
	private String command;
	private String to;
	
	public Message(String command, String to) {
		// super();
		this.command = command;
		this.to = to;
	}

	public String getCommand() {
		return command;
	}

	public String getTo() {
		return to;
	}	
}






import java.util.LinkedList;
import java.util.Queue;
/*
 * 최지만에게 메일을 보냅니다.
 * 류현진에게 SMS를 보냅니다.
 * 김광현에게 카카오톡을 보냅니다.
 * 김하성에게 페이스북메세지를 보냅니다.
 */
public class MessageTest {
	
	public static void main(String[] args) {
		Queue<Message> mQueue = new LinkedList<>();
		
		mQueue.offer(new Message("sendEmail", "최지만"));
		mQueue.offer(new Message("sendSMS", "류현진"));
		mQueue.offer(new Message("sendKakaotalk", "김광현"));
		mQueue.offer(new Message("sendFB", "김하성"));
	
		while(!mQueue.isEmpty()) {
			Message message = mQueue.poll();	// poll()로 받아와서 message에 넣기
			switch(message.getCommand()) {
				case "sendEmail":
					System.out.println(message.getTo() + "에게 메일을 보냅니다.");
					break;
				case "sendSMS":
					System.out.println(message.getTo() + "에게 SMS를 보냅니다.");
					break;
				case "sendKakaotalk":
					System.out.println(message.getTo() + "에게 카카오톡을 보냅니다.");
					break;
				case "sendFB":
					System.out.println(message.getTo() + "에게 페이스북메세지를 보냅니다.");
					break;
			}
		}
	}
}

8. Iterator로 순회하기
    1) Collection의 객체를 순회하는 인터페이스
    2) iterator() 메서드 호출
    3) Iterator에 선언된 메서드
        - boolean hasNext() : 이후에 요소가 더 있는지를 체크하는 메서드, 요소가 있다면 true를 반환함
        - E next() : 다음에 있는 요소를 반환함

9. Set 인터페이스
    1) Collection 하위의 인터페이스
    2) 중복을 허용하지 않음
    3) List는 순서기반의 인터페이스지만, Set은 순서가 없음
    4) get(i) 메서드가 제공되지 않음 (Iterator로 순회)
    5) 저장된 순서와 출력순서는 다를 수 있음
    6) 아이디, 주민등록번호, 사번 등 유일한 값이나 객체를 관리할 때 사용
    7) TreeSet, HashSet 클래스

10. HashSet 클래스 
    1) Set 인터페이스를 구현한 클래스
    2) 중복을 허용하지 않으므로 저장되는 객체의 논리적 동등함 여부를 알기 위해 equals()와 hashCode() 메서드를 재정의 해야함

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

public class HashSetTest {

	public static void main(String[] args) {
		
		Set<String> set = new HashSet<>();
		System.out.println("사이즈 : " + set.size());	// 사이즈 : 0
		
		set.add("Java");
		set.add("Java");
		set.add("Java");
		set.add("Java");
		set.add("Java");
		set.add("Java");
		set.add("Java");
		set.add("Java");
		System.out.println("사이즈 : " + set.size());	// 사이즈 : 1
		
		set.add("JDBC");
		set.add("JSP");
		set.add("myBatis");
		set.add("Oracle");
		set.add(null);
		set.add(null);
		System.out.println("사이즈 : " + set.size()); // 사이즈 : 6 (null도 중복 저장 안됨)
		System.out.println();
		
		// 반복자 iterator는 set을 통해서 얻음
		Iterator<String> iterator = set.iterator();
		while(iterator.hasNext()) {
			String element = iterator.next();
			System.out.println(element);
			/*
			null
			Java
			myBatis
			JSP	
			JDBC
			Oracle
			 */
		}
		System.out.println();
		
		for(String str : set) {
			System.out.println(str);	// 위와 같은 결과 값
		}
		System.out.println();
		
		set.clear(); 	// 전부 삭제
		if(set.isEmpty()) {
			System.out.println("객체가 없습니다.");	// 객체가 없습니다.
		}
		else {
			System.out.println("객체가 존재합니다.");
		}
	}
}

---

import java.util.Objects;

/*
 * 논리적 동등 객체의 조건
 * 	1) 해쉬코드 값이 같아야 함 (hashCode() 재정의)
 * 	2) 두 개의 객체들의 멤버변수들의 값들이 같아야 함 (equals() 재정의)
 */
public class Member {
	private String name;
	private int age;
	
	public Member(String name, int age) {
		// super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}
	
	/*
	 * hashCode() : 각 객체의 주소값을 변환하여 생성함. 객체의 고유한 정수값
	 * 		   	    두 객체가 동일 객체인지 비교할 때 사용할 수 있음
	 */
	@Override
	public int hashCode() {
		System.out.println("해쉬코드 호출");
		return Objects.hash(this.name, this.age);
	}
	
	@Override
	public boolean equals(Object obj) {
		System.out.println("이퀄스 호출");
		if(obj instanceof Member) {
			Member member = (Member)obj;
			return (member.name.equals(this.name)) && (member.age == this.age);
		}
		else {
			return false;
		}	
	}
}






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

public class HashSetTest02 {

	public static void main(String[] args) {
		HashSet<Member> set = new HashSet<>();
		set.add(new Member("최지만", 30));
		set.add(new Member("최지만", 30));
		set.add(new Member("최지만", 25));
		set.add(new Member("최지만", 17));
	
		System.out.println("총 객체 수 : " + set.size());	// 총 객체 수 : 4
		// 사용자가 설정한 거라서 논리적 동등이 설정이 안 되어 있음 -> hashCode()와 equals() 사용
		// hashCode()와 equals() 사용 후 총 객체 수 : 3 으로 바뀜
		
		Iterator<Member> iterator = set.iterator();
		while(iterator.hasNext()) {
			Member member = iterator.next();
			System.out.println(member.getName() + " : " + member.getAge());
		}
		/*
		 * 최지만 : 30
		 * 최지만 : 25
		 * 최지만 : 17
		 */
		
	}
}

11. Map 인터페이스
    1) key - value pair의 객체를 관리하는데 필요한 메서드가 정의됨
    2) key는 중복될 수 없음, value는 중복 허용
    3) 검색을 위한 자료 구조 
    4) key를 이용하여 값을 저장하거나 검색, 삭제할 때 사용함
    5) 구현 클래스 
        - HashMap, Properties, TreeMap, HashTable

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

public class HashMapTest {

	public static void main(String[] args) {
		
		// 키가 String, 값이 Integer임. 둘 다 객체라는 것에 주목
		Map<String, Integer> map = new HashMap<>();
		System.out.println("사이즈 : " + map.size());	// 사이즈 : 0
		
		map.put("최지만", 95);
		map.put("류현진", 90);
		map.put("김광현", 80);
		map.put("류현진", 95);
		map.put("김광현", 95);
		// map은 중복된 키는 저장하지 않음
		System.out.println("사이즈 : " + map.size());	// 사이즈 : 3
		
		// 중복 저장이 될 경우 마지막에 저장된 값으로 대체가 됨
		System.out.println("값 : " + map.get("류현진"));	// 값 : 95
		System.out.println("값 : " + map.get("김광현"));	// 값 : 95

		// map 컬렉션에 있는 key값만 Set계열로 바꿈
		// 방법 1. keySet : 모든 키를 Set 객체에 담아서 리턴
		Set<String> set = map.keySet();
		
		// 반복자 얻기
		Iterator<String> iterator = set.iterator();
		while(iterator.hasNext()) {
			String key = iterator.next();
			int value = map.get(key);
			System.out.println(key + ", " + value);
		}
		System.out.println();
		
		// 방법 2. entrySet() : 키와 값, 쌍으로 구성된 모든 Map.Entry 객체를 Set에 담아서 리턴
		Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
		// 반복자 얻기
		Iterator<Map.Entry<String, Integer>> entryItreator = entrySet.iterator();
		while(entryItreator.hasNext()) {
			Map.Entry<String, Integer> entry = entryItreator.next();
			String key = entry.getKey();		// 키
			int value = entry.getValue();		// 값
			System.out.println(key + ", " + value);
		}
		
		map.clear();	// 전체 객체 삭제
		System.out.println("사이즈 : " + map.size());	// 사이즈 : 0
	}
}

---

import java.util.Objects;

public class Student {

	private int sno;
	private String name;
	
	public Student(int sno, String name) {
		// super();
		this.sno = sno;
		this.name = name;
	}

	public int getSno() {
		return sno;
	}

	public String getName() {
		return name;
	}
	
	@Override
	public int hashCode() {
		return Objects.hash(this.sno, this.name);
	}
	
	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Student) {
			Student student = (Student)obj;
			return this.sno == student.sno && this.name.equals(student.name);
		}
		
		return false;
	}
}







import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
 * Map<K, V> map = new HashMap<>();
 * 	K는 키 타입, V는 값 타입
 */
public class HashMapTest02 {

	public static void main(String[] args) {
		
		Map<Student, Integer> map = new HashMap<>();
		map.put(new Student(1001, "최지만"), 95);
		map.put(new Student(1001, "최지만"), 90);
		map.put(new Student(1001, "류현진"), 100);
		map.put(new Student(1001, "김하성"), 80);
		
		// key 객체의 중복은 허용하지 않음
		System.out.println("총 Entry 수 : " + map.size());	// 총 Entry 수 : 3
		
		// 뒤에 저장된 것으로 대체됨
		System.out.println("최지만 : " + map.get(new Student(1001, "최지만")));	// 최지만 : 90
		
		// 학번 : 1001, 이름 : 최지만, 점수 : 90 형태로 출력
		Set<Student> keySet = map.keySet();
		Iterator<Student> keyIterator = keySet.iterator();
		while(keyIterator.hasNext()) {
			Student key = keyIterator.next();
			System.out.println("학번 : " + key.getSno() + ", 이름 : " + key.getName() + ", 점수 : " + map.get(new Student(key.getSno(), key.getName())));
		}
		
	}
}

12. HashMap 클래스 
    1) Map 인터페이스를 구현한 클래스 중 가장 일반적으로 사용하는 클래스
    2) pair 자료를 쉽고 빠르게 관리할 수 있음

import java.util.Hashtable;
import java.util.Map;
import java.util.Scanner;

/*
 * HashMap : 신버전
 * HashTable : 구버전
 * 기능은 동일함
 */
public class HashTableTest {

	public static void main(String[] args) {
		Map<String, String> map = new Hashtable<>();
		
		// 객체 추가
		map.put("Spring", "5.3.11");
		map.put("SpringBoot", "2.5.5");
		map.put("SpringTools4", "4.12.0");
		map.put("SpringBatch", "4.3.3");
		
		System.out.println("총 Entry 수 : " + map.size());	// 총 Entry 수 : 4
		
		int count = 0;	// 비밀번호 틀린 횟수 저장
		Scanner scan = new Scanner(System.in);
		
		while(true) {
			System.out.println("아이디와 비밀번호를 입력하세요.");
			System.out.print("아이디 : ");
			String id = scan.nextLine();
			System.out.print("비밀번호 : ");
			String pw = scan.nextLine();
			System.out.println();
			
			if(map.containsKey(id)) {
				// id와 pw가 같다면 로그인 성공, 같지 않으면 pw가 불일치함. 단, 틀린 횟수 1 증가됨
				if(map.get(id).equals(pw)) {
					System.out.println(id + "님 로그인 되었습니다.");
					break;
				}
				else {
					count++;
					System.out.println("비밀번호가 " + count + "회 틀렸습니다.");
					if(count == 3) {
						System.out.println("비밀번호가 " + count + "회 틀렸습니다. 지점을 방문 부탁드립니다.");
						break;
					}
				}
			}
			else {
				System.out.println("아이디가 존재하지 않습니다.");
			}
		}
		
		scan.close();
	}
}