오늘의 목표

1. Generic
2. Generic 클래스 정의
3. Generic 메서드
4. Collection Framework
5. List<>
6. Set<>
7. Map<>

---

내용

Generic

Generic은 클래스에서 사용할 데이터 타입을 외부에서 지정하면서 데이터 타입을 일반화 합니다.
각각의 자료형(int,float,double,long,String...)으로 하나씩 클래스를 정의해야 하는 불편함 없이 제네릭 사용 시 가상의 자료형을 정의 한 후 필요한 객체타입을 매개변수로 선언하여 외부에서 데이터타입을 지정하면 하나의 클래스로 다수의 데이터 타입을 다룰 수 있습니다.

제네릭은 클래스 및 인터페이스 뒤에 <> 타입 인자를 넣어 작성합니다.

public class 클래스 <타입 매개변수>(매개 변수){...}
public interface 인터페이스 <타입 매개변수>(매개 변수){...}

타입 매개변수는 일반적으로 대무자 알파벳 한글자로 표현합니다.

• <T> : Type
• <E> : Element
• <K> : Key
• <N> : Number
• <V> : Value
• <R> : Result

Generic의 필요성

public class noneGeneric{
	private Object object; //Object 객체

	noneGeneric(Object object){ //생성자
		this.object = object;
	}
	public void  set(Object object){ //setter
		this.object = object;
	}
	public Object get(){ //getter
		return object;
	}
}

최상위 객체 Object를 필드 타입으로 사용하였습니다. 모든 class로의 업캐스팅이 가능하므로 어떤 타입의 데이터가 들어오더라도 저장할 수 있습니다.

public class Main{
	public static void main(String[] args){
		noneGeneric nonegeneric = new noneGeneric("String");
		String s = (String) nonegeneric.get(); //다운 캐스팅
		Integer i = (Integer) nonegeneric.get(); //에러 발생, String으로 업캐스팅했던
        객체는 Integer로 다운캐스팅 할 수 없음
	}
}

noneGeneric의 object필드는 Object타입이므로 어떤 Wrapper class도 업캐스팅할 수 있습니다.
하지만, 반환할땐 다시 하위클래스로 다운캐스팅을 해야 하위클래스 참조_변수가 가리킬 수 있게 됩니다.
업캐스팅은 타입 생략가능 하지만 다운캐스팅은 타입을 반드시 명시해야 하므로 하위클래스를 명시해야 하기 때문에 반환할때마다 적정한 타입을 명시하지 않는다면 에러를 발생시킵니다.
수십, 수백개만 되어도 타입 명시에 대한 에러가 발생할 확률이 높기 때문에 자바에선 5버전부터 제네릭이 추가되었습니다.

Generic의 장점

• 타입 명시, 형변환을 생략해서 코드가 한결 간결해 집니다.
• 필드나 메서드에서 사용되는 객체 타입의 안정성을 제공합니다.

---

Generic 클래스 정의

Generic 클래스는 참조 자료형을 사용해야 할 경우 Object가 아닌 문자 하나를 지정합니다.

접근제어자 class 클래스<T>{...} //제네릭 타입 매개변수가 1개일때, 보통 많이 사용
접근제어자 class 클래스 <K,V>{...} //제네릭 타입 매개변수가 2개일때

제네릭 타입으로 클래스를 지정하기 위해선 제네릭 타입을 설정해 주고, 필드, 매개변수, 리턴 값을 T로 설정 해줍니다.

package JAVA_Collection;

class MyGeneric<T> { //템플릿 타입 T
    private T t; //필드
    public T get(){return t;} //매서드
    public void set(T t){this.t = t;}
}

public class Collection_init {
    public static void main(String[] args) {
        MyGeneric<String> myGeneric1 = new MyGeneric<>(); //타입 매개변수 = String
        myGeneric1.set("String"); //String으로 파라미터
        String str = myGeneric1.get(); //String으로 return

        MyGeneric<Integer> myGeneric2 = new MyGeneric<>(); //타입 매개변수 = Integer
        myGeneric2.set(1); //Integer로 파라미터
        int value = myGeneric2.get(); //자동 언박싱
    }
}

객체 생성시 매개변수 T는 어떤 데이터 타입을 받을 것인지 지정합니다. 클래스에 지정된 제네릭 타입은 객체 소멸 까지 유지되며 리턴시 다운캐스팅처럼 타입 명시를 하지않아도 되는 장점이 있습니다.

Generic 클래스 사용

제네릭 클래스는 4단계로 구현할 수 있을 것입니다.

1. 템플릿 형태의 제네릭 클래스 정의

class 제네릭클래스<T> {}

2. 템플릿 형태의 제네릭 클래스에 필드와 메서드 정의

class 제네릭클래스<T>{
private T t;
public T get() {return t;}
public void set(T t){this.t=t;}
}

3. 제네릭 클래스의 인스턴스 생성

제네릭클래스<String> gc = new 제니릭클래스<>();

4. 제네릭 객체 사용

gc.set("코딩 자투리");
System.out.println(gc.get()); //코딩 자투리

타입 매개변수

제네릭 클래스<>안에 변수명을 타입 매개변수, 혹은 타입 변수라고도 합니다. 각 변수의 이름, 타입을 구분하기 위하여 하나의 대문자로 작성합니다. 즉 하나의 대문자를 여러개 지정하여 타입 매개변수를 여러개 가질 수 있습니다.

접근지정자 class 제네릭클래스<T,K,V>{...} //타입 매개변수가 3개인 제네릭 클래스

다이아몬드 연산자

다이아몬드 연산자는 특별히 지정해 주어야 하는 것은 아닙니다. 자바 7버전 부터는 제네릭 클래스를 생성할 때 참조_변수쪽이 아닌 생성자 쪽에서 타입 매개변수를 생략할 수 있습니다 .타입 매개변수가 생략된 <>를 다이아몬드 연산자 라고 합니다.

제네릭클래스 <타입 매개변수> 참조_변수 = new 제네릭클래스 <> (); //생성자 타입 매개변수 생략

와일드 카드

와일드 카드는 ?로 표현하며 제한을 두지 않는다는 의미를 가지고 아직 알려지지 않은 타입을 나타냅니다.

• <?> : 제한이 없으며 말 글대로 어떤 것이라는 뜻 입니다. 어떤 자료형도 제한없이 사용할 수 있습니다.
• <? extends T> : T타입을 상한선으로 하여 T타입을 상속받은 하위클래스들만 타입 매개변수로 받습니다.
• <? super T> : T타입을 하한선으로 하여 T타입의 상위 클래스들만 타입 매개변수로 받습니다.

---

Generic 메서드

클래스 전체를 제네릭으로 선언 가능하지만 특정 메서드만 제네릭으로 선언할 수 있습니다. 이것을 제네릭 메서드라고 합니다. 제네릭 메서드는 메서드가 호출되는 시점에서 제네릭 타입을 지정합니다. 제네릭 클래스가 전역 변수와 같이 사용 되었다면 제네릭 메서드는 지역 변수처럼 사용 됩니다.

제네릭 메서드 선언 시

접근지정자 <T> T 메서드(T,t){...} //타입 매개변수 1개
접근지정자 <K,V> void 메서드(K K, V v){...} //타입 매개변수 2개

제네릭 메서드 호출 시

객체.<타입 매개변수>메서드(파라미터) //타입 매개변수를 명시한 경우
객체.메서드(파라미터) //타입 매개변수는 생략 가능

package JAVA_Collection;

class TestClass{ //제네릭 클래스는 아닙니다.
    public <T> T accept(T t){ //타입 매개변수 1개 제네릭 메서드
        return t;
    }
    public <K,V> void getPrint(K k,V v){ //타입 매개변수 2개 제네릭 메서드
        System.out.println(k + " : " + v);
    }
}

public class GenericMethod {
    public static void main(String[] args) {
        TestClass testClass = new TestClass(); //일반적인 클래스

        String str1 = testClass.<String>accept("코딩 자투리"); //타입 매개변수 명시
        String str2 = testClass.accept("코딩 자투리"); //타입 매개변수 생략

        System.out.println(str1);
        System.out.println(str2);

        testClass.<String, Integer>getPrint("코딩 자투리",1); //타입 매개변수 명시
        testClass.getPrint("코딩 자투리",2); //타입 매개변수 생략
    }
}

제네릭 메서드는 메서드 호출시 타입이 결정됩니다. 즉 메서드를 호출하기 전 정의하는 단계에서는 어떤 제네릭을 사용할 것인지 알 수 없습니다. 그래서 클래스의 메서드는 정의하는 시점에서 사용할 수 없습니다.

public <T> void print(T t){
	t.length() //String의 메서드 length()사용 불가
}

정의 하는 시점에서 T가 String인지 알 수 없으므로 String의 메서드는 사욯할 수 없습니다.

public <T> void getPrint(T t){
	t.equals("코딩 자투리"); //Object의 메서드 equals()사용 가능
}

반면에 자바의 최상위 클래스 Object의 메서드는 사용이 가능합니다.

Object의 메서드 : https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html

---

Collection Framework

자바에서 데이터를 효율적으로 저장하기 위해 널리 알려진 자료구조를 바탕으로 객체들을 추가,삭제,수정,검색 등을 할 수 있는 컬랙션을 만들고, 인터페이스 와 클래스를 포함시켰습니다. 이 모든것을 컬랙션 프레임워크(Collection Framework)라고 합니다.

컬렉션 프레임 워크의 주요 인터페이스는 Collection, List, Set, Map등이 있습니다.

Collection은 컬랙션 List와 Set의 최상위 인터페이스 이며 기초적인 메서드를 제공합니다.
나머지 인터페이스 중 List와 Set이 객체를 추가,삭제,검색하는 방법에서 많은 메서드들이 유사합니다.
Map은 키와 값을 한 쌍으로 묵어 관리하는 구조입니다. 하나의 값을 저장하는 Collection인터페이스와 달라 따로 분리되어 있는 인터페이스 입니다.

인터페이스별 특징

• List : 순서 보장, 중복 허용 : 클래스는 ArrayList, LinkedList, Vector등이 있습니다.
• Set : 순서 보장하지 않음, 중복 허용하지 않음 : 클래스는 HashSet, TreeSet, LinkedHashSet등이 있습니다.
• Map : 키(key)와 값(value)쌍 저장, 순서 보장 하지 않음, 중복 허용하지 않음 : 클래스는 HashMap, Hashtable, Properties등이 있습니다.

Collection 인터페이스의 메서드

• boolean add(Object o), addAll(Collection c) : 주어진 객체 / 컬렉션의 객체들을 컬렉션에 추가
• boolean contains(Object o), containsAll(Collection c) : 주어진 객체 / 컬렉션이 저장되어 있는지 여부
• Iterator iterator() : 이터레이터 반환
• boolean equals(Object o) : 컬렉션이 동일한지 여부
• boolean isEmpty() : 컬렉션이 비었는지 여부
• int size() : 컬렉션에 저장된 객체의 수를 반환
• void clear() : 컬렉션에 저장된 객체들을 모두 삭제
• boolean remove(Object o), removeAll(Collection c) : 주어진 객체 / 컬렉션을 삭제하고 성공 여부 반환
• boolean retainAll(Collection c) : 주어진 컬렉션을 제외한 모든 객체를 컬렉션에서 제거하고 변화 여부 반환
• Object[] toArray() : 컬렉션에 주어진 객체를 객체배열로 반환
• Object[] toArray(Object[] a) : 주어진 배열에 컬렉션의 객체를 저장해서 반환(배열의 크기가 크거나 같아야 함)

---

List<>

List

List 인터페이스의 메서드

• void add(int index, Object element) : 주어진 인덱스에 객체를 추가
• boolean addAll(int index, Collection c) : 주어진 인덱스에 컬렉션을 추가
• Object set(int index, Object element) : 주어진 위치에 객체를 저장
• Object get(int index) : 주어진 인덱스에 저장된 객체를 반환
• int indexOf(Object o) / lastIndexOf(Object o) : 순방향 / 역방향으로 탐색하여 주어진 객체의 위치를 반환
• List subList(int from, int to) : from부터 to까지의 객체를 담은 리스트 반환
• Object remove(int index) : 주어진 인덱스에 저장된 객체를 삭제하고 삭제된 객체를 반환
• boolean remove(Object o) : 주어진 객체를 삭제
• void sort(Comparator c) : 주어진 비교자로 List를 정렬

ArrayList

ArrayList는 List인터페이스를 구현한 클래스입니다. Vector와 기능이 유사하고 가장 빈번하게 사용되는 컬렉션 프레임워크 중 하나입니다.

ArrayList에선 객체가 인덱스로 관리되고 연속적으로 존재한다는 점에서 배열과 유사하지만, 배열은 처음 지정한 크기가 고정되는 반면 ArrayList는 저장 용량을 초과하면 자동으로 저장용량이 늘어나게 됩니다.

List<타입 파라미터> 리스트 = new ArrayList<타입 파라미터>(초기용량);
List<타입 파라미터> 리스트 = new ArrayList<>(); //타입 파라미터, 초기용량(10) 생략가능
List<타입 파라미터> 리스트 = new ArrayList<>(리스트); //깊은 복사

데이터의 삽입 삭제시에도 자동으로 연속성을 유지시켜 줍니다. 중간의 객체가 제거되어도 그 뒤의 객체 묶음들이 한칸 씩 앞으로 당겨집니다. 삽입, 삭제가 빈번한 곳에서는 LinkedList를 사용하는 것이 좋습니다.

package JAVA_Collection;

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

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(); //ArrayList 선언

        list.add("java"); //값 추가
        list.add("egg");
        list.add("tree");

        int size = list.size(); //객체의 수 반환
        String skill = list.get(0); //0번째 인덱스 값 반환

        for(int i=0;i<list.size();i++){ //리스트의 객체들을 순서대로
            String str = list.get(i); //값 반환
            System.out.println(i + " : " + str);
        }
        list.remove(0); //0번째 인덱스 객체 삭제
    }
}
//Console
0 : java
1 : egg
2 : tree

ArrayList : https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html

LinkedList

LinkedList는 효율적으로 데이터를 추가,삭제,변경하기 위해 사용됩니다. LinkedList는 수서는 보장하지만, 연속적이진 않습니다. 연속적이지 않은 데이터들 끼리 서로 연결되어 있습니다.

ArrayList는 연속적으로 연결되어 있습니다. 따라서 검색을 할 땐 인덱스로 바로 접근 간으하니 빠르고 순차에 변경이 있을 시 연속성을 유지하기 위해 많은 처리가 필요합니다.
LinkedList는 반대로 연속적으로 연결되어 있지 않습니다. 검색을 할 땐 순서대로 따라가야 하므로 많은 처리가 필요하고 변경이 있을 때는 단순히 해당 요소만 변경해주고 연속성을 유지시킬 필요가 없으므로 빠릅니다.

Iterator

자바 컬렉션 프레임워크에서는 컬렉션의 요소들을 읽어오는 방법을 Iterator 인터페이스로 표준화 하고 있습니다. 각 프레임워크 객체에서 iterator()메서드를 호출하여 Iterator인터페이스를 리턴합니다.

• hasNext() : 가져올 객체가 남아있으면 true 반환, 없으면 false 반환
• next() : 컬렉션에서 객체를 하나 가져옵니다.
• remove() : 컬렉션에서 객체를 제거합니다.

보통 hasNext()로 가져올 객체가 있는지를 확인하고 next()로 객체를 가져옵니다.

Iterator<String> iterator = list.iterator();

while(iterator.hasNext()){
	String str = iterator.next();
}

컬렉션에서 iterator.remove()는 next()에서 가져온 객체를 제거할 때 사용됩니다. 실제 해당 컬렉션에서 객체가 삭제됩니다.

Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
	String str = iterator.next();
    if(str.equals("str과 같은 단어")){
    	iterator.remove();
    }
}

---

Set<>

Set

Set은 중복을 허용하지 않고, 순서를 보장하지 않습니다. 집합이 가지는 의미를 생각한다면 더더욱 와 닿을 것 같습니다. Set을 구현한 클래스는 대표적으로 HashSet, TreeSet이 있습니다.

package JAVA_Collection;

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

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>(); //HashSet 선언

        set.add("Java"); //객체 추가
        set.add("Python");
        set.add("Javascript");
        set.add("C++");
        set.add("Kotlin");
        set.add("Ruby");
        set.add("Java"); //중복으로 인해 추가 x

        Iterator<String> it = set.iterator();

        while(it.hasNext())
            System.out.println(it.next()); //순서를 보장하지 않음
    }
}
//Console
Java //2번 들어갔지만 1번만 출력
C++
Javascript
Ruby
Python
Kotlin

순서가 add한 순서와 동일하지 않고, "Java"를 두번 입력했지만 한번만 출력되었습니다.

Tree Set

TreeSet은 이진 탐색 트리 형태로 데이터를 저장합니다. 마찬가지로 Set의 중복 허용x, 순서보장x 는 유지됩니다. 반면 트리구조를 저장시킴으로써 값의 기준에 다라 정렬된 상태로 유지됩니다.

이진 탐색 트리란 최상위 노드 루트로 부터 자신보다 작은 값은 왼쪽으로 자신보다 큰 값은 오른쪽으로 배치 시키는 트리입니다.

package JAVA_Collection;

import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        TreeSet<String> workers = new TreeSet<>(); //TreeSet 선언

        workers.add("이 자바"); //객체 추가
        workers.add("박 헤커");
        workers.add("김 코딩");

        System.out.println(workers);
        System.out.println(workers.first()); //루트 노드 출력
        System.out.println(workers.last()); //마지막 리프 노드 출력
        System.out.println(workers.higher("이")); //"이"보다 나중에 나오는 노드
        System.out.println(workers.subSet("김","박")); //"김"과 "박"사이에 나오는 노드들
    }
}
//Console
[김 코딩, 박 헤커, 이 자바]
김 코딩
이 자바
이 자바
[김 코딩]

Comparator와 Comparable

Comparator와 Comparable은 컬랙션을 정렬하기 위해 자바에서 제공하는 인터페이스 입니다.
Comparable은 비교대상(매개 변수)와 자기자신을 비교하고,Comparator는 매개변수인 두 객체를 비교한다는 것입니다.

• compareTo(비교대상) : 두 객체가 같으면 0, 비교대상이 더 크면 음수, 비교대상이 더 작으면 양수를 반환합니다.

package JAVA_Collection;

import java.util.Set;
import java.util.TreeSet;

//Comparable은 클래스 자신이 구현하여 정렬 기준을 자동으로 만드는 것
class Employee implements Comparable<Employee>{ //Comparable<Employee>를 구현
    int id;
    String name, department;

    public Employee(int id, String name, String department){ //생성자
        this.id = id;
        this.name = name;
        this.department = department;
    }

    public int compareTo(Employee employee){ //추상 메서드
        if(id > employee.id){ //자기자신 > 비교대상
            return 1;
        }else if (id < employee.id){ //자기자신 < 비교대상
            return -1;
        }else{ //자기자신 == 비교대상
            return 0;
        }
    }
}

public class ComparableExample {
    public static void main(String[] args) {
        Set<Employee> workers = new TreeSet<>(); //TreeSet

		//객체 생성
        Employee employee1 = new Employee(11,"Kim Coding","Software Engineering");
        Employee employee2 = new Employee(5,"Lee Java","Growth Marketing");
        Employee employee3 = new Employee(7,"Park Hacker","Software Engineering");
		//Set에 객체 추가
        workers.add(employee1);
        workers.add(employee2);
        workers.add(employee3);
		//출력, Employee내부에서 자동으로 정렬
        for(Employee employee : workers)
            System.out.println(employee.id+" "+employee.name+" "+employee.department+" ");
    }
}
//Console
5 Lee Java Growth Marketing 
7 Park Hacker Software Engineering 
11 Kim Coding Software Engineering 

데이터를 삽입한 순서에 상관없이, CompareTo()메서드에 정의한 값 순서대로 저장되었습니다.

Comaprator 인터페이스는 정렬 기준이 아닌 다른 기준으로 정렬하고 싶을 때 사용합니다.

• compare(비교대상1, 비교대상2) : 두 객체가 같으면 0, 비교대상2이 더 크면 음수, 비교대상2이 더 작으면 양수를 반환합니다. 외부에서 정렬 기준 클래스를 따로 만듭니다.

package JAVA_Collection;

import java.lang.*;
import java.util.*;

class Employee2 { //정렬하는 클래스내부에서 기준을 정하지 않습니다.
    int id;
    String name,department;

    public Employee2(int id, String name, String department) { //생성자
        this.id = id;
        this.name = name;
        this.department = department;
    }
}

class SortbyId implements Comparator<Employee2> { //정렬을 기준을 구현한 클래스를 따로 만듭니다. 
    public int compare(Employee2 employee1, Employee2 employee2){ //Compare()메서드 오버라이딩
        return employee1.id - employee2.id; //id값 비교
    }
}

public class ComparatorExample {
    public static void main(String[] args) {
        ArrayList<Employee2> workers = new ArrayList<>(); //리스트 생성
		//객체 생성
        Employee2 employee1 = new Employee2(11, "Kim Coding", "Software Engineering");
        Employee2 employee2 = new Employee2(5, "Hello World", "Growth Marketing");
        Employee2 employee3 = new Employee2(7, "Park Hacker", "Software Engineering");
		//리스트에 객체 추가
        workers.add(employee1);
        workers.add(employee2);
        workers.add(employee3);
		//정렬 전 리스트 출력
        for (Employee2 employee:workers) {
            System.out.println(employee.id + " " + employee.name + " " + employee.department + " ");
        }
		//정렬
        Collections.sort(workers,new SortbyId());
		//정렬 후 리스트 출력
        for (Employee2 employee:workers) {
            System.out.println(employee.id + " " + employee.name + " " + employee.department + " ");
        }
    }
}
//Console
//정렬 전
11 Kim Coding Software Engineering 
5 Hello World Growth Marketing 
7 Park Hacker Software Engineering 
//정렬 후
5 Hello World Growth Marketing 
7 Park Hacker Software Engineering 
11 Kim Coding Software Engineering 

Comparator<E> 인터페이스를 구현한 클래스를 적용시켜 리스트를 정렬하기 위해서는 Comparable과는 다르게 추가적인 메서드 호출 작업이 필요합니다. Collections.sort(컬렉션,Comparator<E>를 구현한 객체)로 정렬 합니다.

---

Map<>

Map

Map 인터페이스는 키(Key)와 값(Value) 쌍으로 구성된 Entry 객체를 저장하는 구조입니다. Set처럼 순서를 보장하지 않고 중복 저장이 불가능 합니다.
Map 인터페이스를 구현한 클래스에는 HashMap, Hashtable, TreeMap, SortedMap등이 존재합니다.

• Object put(Object key, Object value) : 주어진 키와 값을 저자합니다. 새로운 키일 경우 null을 반환하고, 동일한 키가 있을 경우 대체하고 이전 값을 리턴합니다.
• boolean containsKey(Object key) : 주어진 키가 있으면 true, 없으면 false를 리턴
• boolean containsValue(Object value) : 주어진 값이 있으면 true, 없으면 false를 리턴
• Set entrySet() : 키와 값의 쌍으로 구성된 모든 Map.Entry 객체를 Set에 담아서 리턴
• Object get(Object key) : 키에 해당하는 값을 리턴
• boolean isEmpty() : 컬렉션이 비어 있는지 확인
• Set keySet() : 모든 키를 Set객체에 담아서 리턴
• int size() : 지정된 키-값 쌍의 총 갯수를 리턴
• Collection values() : 모든 값을 Collection에 담아 리턴
• void clear() : 모든 Map.Entry(키와 값)을 삭제
• Object remove(Object key) : 키와 일치하는 Map.Entry를 삭제하고 값을 리턴

HashMap

HashMap은 해시 함수를 통해 키와 값이 저장되는 위치를 결정하므로 사용자는 위치를 알 수 없고 순서와 위치 또한 관계가 없습니다.

HashMap의 키로 사용할 객체는 hashCode()와 equals()메서드를 재정의 해서 동등 개체가 될 조건을 정해야 합니다. 동등 객체, 즉 동일한 키가 될 조건은 HashSet과 동일합니다. hashCode()의 리턴 값이 같아야 하고, equals()메서드가 true를 리턴해야 합니다.

package JAVA_Collection;

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

public class HashMapExample {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>(); //해시맵 생성

		//객체 추가
        map.put("피카츄",85);
        map.put("꼬부기",95);
        map.put("야도란",75);
        map.put("파이리",65);
        map.put("피존투",15);
		
        //해시 맵 내 객체 출력
        System.out.println("총 entry 수 : " + map.size());
		//파이리 값 출력
        System.out.println("파이리 : " +  map.get("파이리"));

        System.out.println("///");
		//키들 리턴
        Set<String> keySet = map.keySet();
		//키만 따로 iterator해서 순회 가능합니다.
        Iterator<String> keyIterator = keySet.iterator();
        while(keyIterator.hasNext()){
            String key = keyIterator.next();
            Integer value = map.get(key); //키로 값을 얻응 수 있습니다.
            System.out.println(key + " : " + value);
        }
		//해시맵에서 삭제합니다.
        map.remove("피존투");
        System.out.println("///");
        System.out.println("총 entry 수 : " + map.size());
		//해시맵entrySet()은 Map.Entry<키 클래스,값 클래스>를 리턴합니다.
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        //Map.Entry<>들을 담고 있는 Set을 Iterator로 반환합니다.
        Iterator<Map.Entry<String,Integer>> entryIterator = entrySet.iterator();

        while(entryIterator.hasNext()){
            Map.Entry<String,Integer> entry = entryIterator.next();
            String key = entry.getKey(); //키 반환
            Integer value = entry.getValue(); //값 반환
            System.out.println(key + " : " + value);
        }
        map.clear();
    }
}
//Console
총 entry 수 : 5
파이리 : 65
///
야도란 : 75
꼬부기 : 95
파이리 : 65
피카츄 : 85
피존투 : 15
///
총 entry 수 : 4
야도란 : 75
꼬부기 : 95
파이리 : 65
피카츄 : 85

package JAVA_Collection;

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

public class HashTableExample {
    public static void main(String[] args) {
        Map<String,String> map = new Hashtable<>();
        map.put("Spring","345");
        map.put("Summer","678");
        map.put("Fall","910111");
        map.put("Winter","1212");

        System.out.println(map);

        Scanner scanner = new Scanner(System.in);

        while(true){
            System.out.println("아이디와 비밀번호를 입력해 주세요");
            System.out.println("아이디");
            String id = scanner.nextLine();

            System.out.println("비밀번호");
            String password = scanner.nextLine();

            if(map.containsKey(id)){ //id 일치 여부혹인
                if(map.get(id).equals(password)){ //id일치, 비밀번호 일치
                    System.out.println("로그인 되었습니다.");
                    break;
                }else{ //id일치, 비밀번호 비일치
                    System.out.println("비밀번호가 일치하지 않습니다.");
                }
            }else //id 비일치
                System.out.println("입력하신 아이디가 존재하지 않습니다.");
        }
    }
}
//Console
{Summer=678, Spring=345, Winter=1212, Fall=910111}
아이디와 비밀번호를 입력해 주세요
아이디
season
비밀번호
1234
입력하신 아이디가 존재하지 않습니다.
아이디와 비밀번호를 입력해 주세요
아이디
Spring
비밀번호
345
로그인 되었습니다.

---

후기

자바의 제네릭 클래스, Collection Framework는 모두 자주 사용되고 정말 중요합니다. 특히나 코딩테스트를 고려하고 있다면 절대로 배제할 수 없습니다. 저도 연습할때마다 항상 느끼는 것이 Collection Framework를 평소에 자주 익혀둘걸 이라고 생각 많이 했었습니다. 더 많은 인터페이스, 클래스, 메서드들이 존재하는 시간날때 틈틈히 챙겨보는 것도 좋은 습관이라 생각합니다.

---

GitHub

https://github.com/ds02168/CodeStates/tree/main/src/JAVA_Collection