🎃 Collection

컬렉션(Collection) 이란 사전적 의미로 요소를 수집해서 저장하는 것을 말합니다.

프로그래밍을 하다보면 다수개의 객체를 저장해 두고 필요할 때 마다 꺼내서 사용하는 경우가 있습니다. 만약 10개의 Product 객체를 저장해 두고, 필요할 때 하나씩 꺼내서 이용한다고 가정해봅시다. 어떻게 효율적으로 Product 객체를 추가, 검색, 삭제할지 고민해야하는데, 가장 간단한 방법은 배열을 이용하는 것이죠.

// 길이 10인 배열 생성
Product[] productArray = new Product[10];

// 객체 추가
productArray[0] = new Product("상품0");
productArray[1] = new Product("상품1");
productArray[2] = new Product("상품2");

// 객체 검색
Product model0 = productArray[0];
Product model1 = productArray[1];
Product model2 = productArray[2];

// 객체 삭제
productArray[0] = null;
productArray[1] = null;
productArray[2] = null;

배열은 쉽게 생성하고 사용할 수 있지만, 저장할 수 있는 객체 수가 배열을 생성할 때 결정되기 때문에 불특정 다수의 객체를 저장하기에는 문제가 있습니다. 물론 배열의 크기를 처음에 크게 생성하면 되지만, 이것은 좋은 방법이 될 수 없습니다. 배열의 또 다른 문제점은 객체를 삭제했을 때 해당 인덱스가 비게 되어 낱알이 듬성듬성 빠진 옥수수가 될 수 있습니다. 그렇기 때문에 새로운 객체를 저장하려면 어디가 비어있는지 확인하는 코드도 필요하겠죠.

자바는 배열의 이런 문제점을 해결하고, 널리 알려져 있는 자료구조를 바탕으로 객체들을 효율적으로 추가,삭제,검색할 수 있도록 java.util 패키지에 컬렉션과 관련된 인터페이스와 클래스들을 포함시켜 놓았습니다. 이들을 총칭해서 컬렉션 이라 부릅니다.

자바에서는 몇가지 컬렉션 인터페이스를 통해 다양한 형태의 자료구조를 제공해주는데, 주요 인터페이스로 List, Set, Map이 있습니다. 다음은 이 인터페이스로 사용 가능한 컬렉션 클래스를 보여줍니다.

• List 인터페이스를 구현한 클래스 : ArrayList, Vector, LinkedList
• Set 인터페이스를 구현한 클래스 : HashSet, TreeSet
• Map 인터페이스를 구현한 클래스 : HashMap, Hashtable, TreeMap, Properties

List와 Set은 객체를 추가, 삭제, 검색하는 방법에 많은 공통점이 있는데 이 인터페이스들의 공통된 메소드만 모아 Collection 인터페이스로 정의해 두고 있습니다.
Map은 키(Key)와 값(Value)을 하나의 쌍으로 묶어서 관리하는 구조로 되어있는데, 앞서 언급했던 List나 Set과는 자료구조의 사용 방법이 전혀 다릅니다.

다음 챕터에서 List, Set, Map 각각의 자료구조에 대하여 더욱 자세히 알아보겠습니다.

🎄 List - ArrayList, LinkedList

List 컬렉션은 객체를 일렬로 늘어놓은 구조를 가지고 있습니다. 앞에서 언급했던 배열도 같은 특징을 가지고있지만, 배열은 선언 시점에 저장할 수 있는 크기가 결정이 되기 때문에 명확하지 않은 경우에는 선언하기가 어려운 단점을 가지고 있습니다. 이런 단점을 보완한, 자료형의 개수가 계속 변하는 상황에서 유리한 자료구조 형태가 바로 List입니다.
List 컬렉션은 객체 자체를 저장하는게 아니라 다음 그림과 같이 객체의 번지를 참조합니다. null도 저장이 가능한데, 이 경우 해당 인덱스는 객체를 참조하지 않습니다.

다음은 List 컬렉션에 저장되는 구체적인 타입을 String으로 정해놓고 추가, 찾기, 그리고 삭제하는 것을 코드로 보여줍니다.

List<String> list = ...;
list.add("홍길동");
list.add(1, "삼길동");
String str = list.get(1);
list.remove(0);
list.remove("삼길동");

만약 전체 객체를 대상으로 하나씩 반복해서 저장된 객체를 얻고 싶다면 다음과 같이 for문을 사용할 수 있습니다.

List<String> list = ...;
for (int i = 0; i < list.size; i++) {
	String str = list.get(i);  // i 인덱스에 저장된 String 객체를 가져옴
}

인덱스 번호가 필요 없다면 향상된 for문을 이용하는 것이 더욱 편리합니다.

for (String str : list) {   // 저장된 list 총 갯수만큼 루핑
}

아래 표는 List 컬렉션에서 공통적으로 사용 가능한 List 인터페이스의 메소드들입니다. 인덱스로 객체 관리를 하기 때문에 인덱스를 매개값으로 갖는 메소드가 많습니다.

기능	메소드	설명
객체 추가	boolean add(E e)	주어진 객체를 맨 끝에 추가
	void add(int index, E element)	주어진 인덱스에 객체를 추가
	set(int index, E element)	주어진 인덱스에 저장된 객체를 주어진 객체로 바꿈
객체 검색	boolean contains(Object o)	주어진 객체가 저장되어있는지 여부
	E get(int index)	주어진 인덱스에 저장된 객체를 리턴
	isEmpty()	컬렉션이 비어있는지 여부
	int size()	저장되어 있는 전체 객체 수 리턴
객체 삭제	void clear()	저장된 모든 객체를 삭제
	E remove(int index)	주어진 인덱스에 저장된 객체를 삭제
	boolean remove(Object o)	주어진 객체를 삭제

ArrayList

ArrayList는 List 인터페이스의 구현 클래스로, ArrayList에 객체를 추가하게되면 객체가 인덱스로 관리됩니다. 일반 배열과 ArrayList는 인덱스로 객체를 관리한다는 점에서는 같지만, 큰 차이점을 갖고있습니다.
배열은 생성할 때 크기가 고정되고 사용 중에 크기를 변경할 수 없지만, ArrayList는 저장 용량(capacity)을 초과한 객체들이 들어오면 자동적으로 저장 용량(capacity)이 늘어납니다.
ArrayList의 내부 구조를 보겠습니다.

기본 생성자로 ArrayList를 생성하면 내부에 10개의 객체를 저장할 수 있는 초기 용량을 가지게 됩니다. 저장되는 객체 수가 늘어나면 용량이 자동으로 증가하지만, 처음부터 용량을 크게 잡고싶다면 크기를 매개값으로 넣는 생성자를 이용하면 됩니다.

List<String> list = new ArrayList<String>(30);  //String객체 30개를 저장할 수 있는 용량

ArrayList에 객체를 추가하면 인덱스 0부터 차례대로 저장됩니다. 만약 ArrayList에서 특정 인덱스의 객체를 제거하면 바로 뒤 인덱스부터 마지막 인덱스까지 모두 앞으로 1씩 당겨집니다. 마찬가지로 특정 인덱스에 객체를 삽입하면 해당 인덱스부터 마지막 인덱스까지 모두 1씩 밀려납니다.
다음 그림은 4번 인덱스가 제거되었을 때 5번 인덱스부터 모두 앞으로 1씩 당겨지는 모습을 보여줍니다.

따라서 빈번한 객체 삭제와 삽입이 일어나는 곳에서는 ArrayList를 사용하는 것이 바람직하지 않습니다.
이 경우라면, LinkedList를 사용하는 것이 좋습니다. 그러나 인덱스 검색, 맨마지막에 객체를 추가하는 경우라면 ArrayList가 더 좋은 성능을 발휘합니다.
다음 예제는 ArrayList에 String 객체를 추가, 검색, 삭제하는 방법을 보여줍니다.

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

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

		// String 객체를 저장
		list.add("Java");
		list.add("Spring");
		list.add("Servlet/JSP");
		list.add("DBMS");
		list.add("JPA");

		int size = list.size();
		System.out.println("총 객체 수: " + size);
		System.out.println();

		String skill = list.get(2);
		System.out.println("Skill 2: " + skill);
		System.out.println();

		for (int i = 0; i < list.size(); i++) {
			String str = list.get(i);
			System.out.println(i + ": " + str);
		}
		System.out.println();

		list.remove(2);		// 2번 인덱스(Servlet/JSP) 삭제
		list.remove(2);		// 2번 인덱스(DBMS) 삭제 
		list.remove("Java");

		for (int i = 0; i < list.size(); i++) {		// 저장된 총 객체 수만큼 루핑
			String str = list.get(i);
			System.out.println(i + ": " + str);
		}

	}
}

<실행결과>

총 객체 수: 5

Skill 2: Servlet/JSP

0: Java
1: Spring
2: Servlet/JSP
3: DBMS
4: JPA

0: Spring
1: JPA

LinkedList

LinkedList는 List 구현 클래스이므로 ArrayList와 사용 방법은 똑같지만 내부 구조는 완전 다릅니다.
ArrayList는 내부 배열에 객체를 저장해서 인덱스로 관리하지만, LinkedList는 인접 참조를 링크해서 체인처럼 관리합니다.

LinkedList에서 특정 인덱스의 객체를 제거하면 앞뒤 링크만 변경되고 나머지 링크는 변경되지 않습니다. 특정 인덱스에 객체를 삽입할 때도 마찬가지죠. ArrayList는 중간 인덱스의 객체를 제거하면 뒤에 객체는 인덱스가 1씩 앞으로 당겨지기 때문에 빈번한 객체 삭제와 삽입에 불리합니다.
다음은 중간에 객체를 제거할 경우 앞뒤 링크의 수정이 일어나는 모습을 보여주고 있습니다.

LinkedList를 생성하기 위해서는 저장할 객체 타입을 타입 파라미터(E)에 표기하고 기본 생성자를 호출하면 됩니다. LinkedList가 처음 생성될 때에는 어떠한 링크도 만들어지지 않았기 때문에 내부는 비어있다고 보면 됩니다.

List<E> list = new LinkedList<E>();

다음 예제는 ArrayList와 LinkedList에 10,000개의 객체를 삽입하는 데 걸린 시간을 측정한 예제입니다.
0번 인덱스에 String 객체를 10,000번 추가하기 위해 List 인터페이스의 add(int index, E element)메소드를 이용했습니다.

public class LinkedListExample {

	public static void main(String[] args) {
		List<String> arrayList = new ArrayList<>();
		List<String> linkedList = new LinkedList<>();

		long startTime;
		long endTime;

		startTime = System.nanoTime();
		for (int i = 0; i < 10000; i++) {
			arrayList.add(0, String.valueOf(i));
		}
		endTime = System.nanoTime();
		System.out.println("ArrayList 걸린시간: " + (endTime - startTime) + "ns");

		startTime = System.nanoTime();
		for (int i = 0; i < 10000; i++) {
			linkedList.add(0, String.valueOf(i));
		}
		endTime = System.nanoTime();
		System.out.println("LinkedList 걸린시간: " + (endTime - startTime) + "ns");
	}
}

실행 결과를 보면 LinkedList가 ArrayList보다 훨씬 빠른 성능을 보입니다.

ArrayList 걸린시간: 56252133ns
LinkedList 걸린시간: 3332620ns

실행 결과에서도 알 수 있듯이, 중간에 추가 또는 삭제할 경우는 앞뒤 링크만 변경하면 되는 LinkedList가 더 빠릅니다. ArrayList는 뒤쪽 인덱스들을 모두 1씩 증가 또는 감소 시키는 시간이 필요하므로 처리 속도가 느립니다.

🫠 Set - HashSet

List 컬렉션과 Set 컬렉션은 큰 차이점이 있습니다. List 컬렉션은 저장 순서를 유지하지만, Set 컬렉션은 저장 순서가 유지되지 않습니다. 또한 객체를 중복해서 저장할 수 없다는 큰 특징이 있습니다.

Set 컬렉션에는 HashSet, LinkedHashSet, TreeSet 등이 있는데, 다음은 Set 컬렉션에서 공통적으로 사용 가능한 Set 인터페이스의 메소드들입니다.

기능	메소드	설명
객체 추가	boolean add(E e)	주어진 객체를 저장, 객체가 성공적으로 저장되면 true를 리턴하고 중복 객체면 false를 리턴
객체 검색	boolean contains(Object o)	주어진 객체가 저장되어 있는지 여부
	isEmpty()	컬렉션이 비어 있는지 조사
	Iterator iterator()	저장된 객체를 한 번씩 가져오는 반복자 리턴
	int size()	저장되어 있는 전체 객체 수 리턴
객체 삭제	void clear()	저장된 모든 객체를 삭제
	boolean remove(Object o)	주어진 객체를 삭제

Set<String> set = ..;
set.add("카리나");
set.add("윈터");
set.remove("카리나");

Set 컬렉션은 저장 순서가 유지되지 않기 때문에 인덱스로 객체를 가져올 수 없습니다. 그래서 인덱스로 객체를 검색해서 가져오는 메소드가 없죠. 대신, 전체 객체를 대상으로 한번씩 반복해서 가져오는 반복자(iterator)를 제공합니다. 반복자는 Iterator 인터페이스를 구현한 객체를 말하는데, iterator() 메소드를 호출하면 얻을 수 있습니다.

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

다음은 Iterator 인터페이스에 선언된 메소드들입니다.

리턴 타입	메소드명	설명
boolean	hasNext()	가져올 객체가 있으면 true를 리턴하고 없으면 false를 리턴합니다
E	next()	컬렉션에서 하나의 객체를 가져옵니다
void	remove()	Set 컬렉션에서 객체를 제거합니다

Iterator에서 하나의 객체를 가져올 때는 next() 메서드를 사용합니다. next() 메서드를 사용하기 전에 먼저 가져올 객체가 있는지 확인하는 것이 좋겠죠? 이때 hasNext() 메소드를 사용합니다. hasNext() 메소드는 가져올 객체가 있으면 true를 리턴하고, 없으면 false를 리턴해줍니다. 따라서 true가 리턴될 때 next() 메소드를 사용해야 합니다. 다음은 Set 컬렉션에서 String 객체들을 반복해서 하나씩 가져오는 코드를 보여줍니다.

Set<String> set = ...;

Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {		// 저장된 객체 수만큼 루핑
	String str = iterator.next(); // String 객체 하나를 가져옴
}

Iterator를 사용하지 않더라도 향상된 for문을 이용해서 전체 객체를 대상으로 반복할 수 있습니다.

Set<String> set = ...;
for (String str : set) {  //저장된 객체 수만큼 루핑

}

그리고 Set 컬렉션에서 Iterator의 next() 메소드로 가져온 객체를 제거하고싶다면 remove() 메소드를 사용하면 됩니다. Iterator의 메소드이지만, 실제 Set 컬렉션에서 객체가 제거됩니다. 다음 코드를 볼게요.

Set<String> set = ...;

Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {   // 저장된 객체 수만큼 루핑
	iterator.remove();           // 객체 제거
}

HashSet

HashSet은 Set 인터페이스의 구현 클래스입니다. HashSet을 생성하기 위해서는 다음과 같이 기본 생성자를 호출하면 됩니다.

Set<E> set = new HashSet<E>();

앞서 봤던 ArrayList, LinkedList와 마찬가지로, 타입 파라미터 E에는 컬렉션에 저장할 객체 타입을 지정하면 됩니다. 예를 들어 String 객체를 저장하는 HashSet은 다음과 같이 생성할 수 있습니다.

Set<String> set = new HashSet<String>();

HashSet은 객체들을 순서 없이 저장하고 동일한 객체는 중복 저장하지 않습니다. 여기서 말하는 ‘동일한 객체’는 자바에서 어떻게 동일한지 판단할까요? HashSet이 판단하는 동일한 객체란 꼭 같은 인스턴스를 뜻하지 않습니다. HashSet은 객체를 저장하기 전에 먼저 객체의 hashCode() 메소드를 호출해서 해시코드를 얻어냅니다. 그리고 이미 저장되어있던 객체들의 해시코드와 비교하지요. 만약 동일한 해시코드가 있다면 다시 equals() 메소드로 두 객체를 비교해서 true가 나오면 동일한 객체로 판단하고 중복 저장하지 않습니다. 그림으로 보겠습니다.

다음 예제로 HashSet에 String 객체를 추가, 검색, 제거하는 방법을 학습해보겠습니다.

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<>();
		set.add("Java");
		set.add("Spring");
		set.add("Servlet/JSP");
		set.add("Java");
		set.add("DBMS");

		System.out.println("총 객체수: " + set.size());  // 저장된 객체수 출력

		Iterator<String> iterator = set.iterator();    // 반복자 얻기
		while (iterator.hasNext()) {              // 객체 수 만큼 루핑
			String element = iterator.next();       // 한 개의 객체를 가져온다
			System.out.println("\t" + element);
		}

		set.remove("DBMS");      // 한 개의 객체 삭제
		set.remove("Java");      // 한 개의 객체 삭제
		System.out.println("총 객체수: " + set.size());

		iterator = set.iterator();
		while (iterator.hasNext()) { 
			String element = iterator.next();
			System.out.println("\t" + element);
		}

		set.clear();       // 모든 객체를 제거하고 비움
		if (set.isEmpty()) {
			System.out.println("비어있음");
		}
	}
}

<실행결과>

총 객체수: 4
	Java
	Servlet/JSP
	DBMS
	Spring
총 객체수: 2
	Servlet/JSP
	Spring
비어있음

위 코드에 대한 실행결과가 이해가 되셨다면 다음 퀴즈로 넘어갈게요.
아래 코드에 대한 결과는 무엇일까요?

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

public class HashSetExample2 {
	public static void main(String[] args) {
		Set<Member> set = new HashSet<>();

		set.add(new Member("홍길동", 30));
		set.add(new Member("홍길동", 30));

		System.out.println("총 객체수: " + set.size());
	}
}

public class Member {
	String name;
	int age;

	public Member(String name, int age) {
		this.name = name;
		this.age = age;
	}
}

총 객체수: 2

두 번 중복으로 삽입한 Member 인스턴스는 내부 데이터가 동일하지만, 인스턴스가 다르기 때문에 객체 둘 다 저장합니다. 하지만 의도한 바가 아닙니다. 내부 데이터가 동일하기 때문에 중복 처리를 해줄 수 있도록 바꿔보겠습니다.

Member클래스에서 hashCode()와 equals() 메소드를 오버라이딩 해서,
인스턴스가 달라도 이름, 나이가 동일하다면 동일한 객체로 간주하여 중복 저장되지 않도록 코드를 작성해볼게요.

public class Member {
	String name;
	int age;

	public Member(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public int hashCode() {
		return name.hashCode() + age;
	}

	@Override
	public boolean equals(Object obj) {
		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.Set;

public class HashSetExample2 {
	public static void main(String[] args) {
		Set<Member> set = new HashSet<>();

		set.add(new Member("홍길동", 30));
		set.add(new Member("홍길동", 30));   // 인스턴스는 다르지만 내부 데이터가 동일하므로 객체 1개만 저장

		System.out.println("총 객체수: " + set.size());
	}
}

총 객체수: 1

🗺️ Map - HashMap, Hashtable

Map 컬렉션은 키(key)와 값(value)으로 구성된 객체를 저장하는 구조입니다. 여기서 키와 값은 모두 객체입니다. 키는 중복될 수 없지만 값은 중복 저장될 수 있습니다. 만약 기존에 저장되었던 키값과 동일한 키값으로 저장하면 기존의 값은 없어지고 새로운 값으로 대치됩니다.

Map 컬렉션에는 HashMap, Hashtable, LinkedHashMap, Properties, TreeMap 등이 있습니다.
아래 표는 Map 컬렉션에서 공통으로 사용 가능한 Map 인터페이스의 메소드들입니다. ‘Key’로 객체들을 관리하기 때문에 Key를 매개값으로 갖는 메소드가 많습니다.

기능	메소드	설명
객체추가	V put(K key, V value)	주어진 키와 값을 추가, 저장되면 값을 리턴
객체검색	boolean containsKey(Object key)	주어진 키가 있는지 여부
	boolean containsValue(Object value)	주어진 값이 있는지 여부
	Set(Map.Entry<K,V>> entrySet()	키와 값의 쌍으로 구성된 모든 Map.Entry 객체를 Set에 담아서 리턴
	V get(Object key)	주어진 키가 있는 값을 리턴
	boolean isEmpty()	컬렉션이 비어 있는지 여부
	Set keySet()	모든 키를 Set 객체에 담아서 리턴
	int size()	저장된 키의 총 개수 리턴
	Collection values()	저장된 모든 값을 Collection에 담아서 리턴
객체삭제	vold clear()	모든 Map.Entry(키와 값)를 삭제
	V remove(Object key)	주어진 키와 일치하는 Map.Entry를 삭제하고 값을 리턴

위 표에서 메소드의 매개변수 타입과 리턴 타입에 K, V라는 타입의 파라미터가 있는데요, 이것은 Map 인터페이스가 제네릭 타입이기 때문입니다. 구체적인 타입은 구현 객체를 생성할 때 결정됩니다. 객체 추가는 put() 메소드를 사용하고, key로 객체를 찾아올 때에는 get(key) 메소드를 사용합니다. 객체 삭제는 remove(key) 메소드를 사용합니다.

Map<String, Integer> map = ...;
map.put("홍길동", 30);          // 객체 추가
int score = map.get("홍길동");  // 객체 찾기
map.remove("홍길동");           // 객체 삭제

key를 알고있다면 위 코드와같이 get() 메소드를 사용하면 되지만, 저장된 객체 전체를 하나씩 얻고싶은 경우에는

1. keySet() 메소드로 모든 키를 Set 컬렉션으로 얻은 다음, 반복자를 통해 키를 하나씩 얻고 get() 메소드를 통해 값을 얻으면 됩니다.

Map<K, V> map = ...;
Set<K> keySet = map.keySet();
Iterator<K> keyIterator = keySet.iterator();
while(keyIterator.hasNext()) {
	K key = keyIterator.next();
	V value = map.get(key);
}

1. entrySet() 메소드로 모든 Map.Entry를 Set 컬렉션으로 얻은 다음, 반복자를 통해 Map.Entry를 하나씩 얻고 getKey()와 getValue() 메소드를 이용해 키와 값을 얻으면 됩니다.

Set<Map.Entry<String, Object>> entries = map.entrySet();
for (Map.Entry<String, Object> entry : entries) {
	String key = entry.getKey();
	Object value = entry.getValue();
}

HashMap

HashMap은 Map 인터페이스를 구현한 대표적인 Map 컬렉션입니다. HashMap을 생성하기 위해서는 키 타입과 값 타입을 파라미터로 주고 기본 생성자를 호출하면 됩니다.

Map<K, V> map = new HashMap<K, V>(); // K: 키 타입 파라미터, V: 값 타입 파라미터

키와 값의 타입은 Primitive type(byte, short, int, float, long, double, boolean, char)을 사용할 수 없고 클래스 및 인터페이스 타입만 가능합니다. 키로 String 타입을 사용하고 값으로 Integer 타입을 사용하는 HashMap은 다음과 같이 생성할 수 있습니다.

Map<String, Integer> map = new HashMap<String, Integer>();

다음 예제는 이름을 Key로, 점수를 Value로 저장하는 HashMap 사용방법입니다.

아래 코드를 보고 2번 부터 각 단계별 출력 결과를 예상해보세요.

1. Map 컬렉션 생성
2. 객체 찾기 : get() 메소드 이용
3. 객체를 하나씩 처리 : keySet() 메소드 이용
4. 특정 객체 삭제 : remove() 메소드 이용
5. 객체를 하나씩 처리 : entrySet() 메소드 이용
6. 모든 Map.Entry 삭제

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) {
// 1. Map 컬렉션 생성
Map<String, Integer> map = new HashMap<>();

	map.put("홍길동", 80);
	map.put("카리나", 85);
	map.put("제시카", 95);
	map.put("홍길동", 80);        // "홍길동" 키가 같기 때문에 가장 마지막에 저장한 값으로 엎어씀
	System.out.println("총 Entry 수: " + map.size());    // 저장된 총 Entry 수 얻기

	// 2. 객체 찾기
	System.out.println("\t홍길동: " + map.get("홍길동"));
	System.out.println();

	// 3. 객체를 하나씩 처리
	Set<String> keySet = map.keySet();
	Iterator<String> iterator = keySet.iterator();
	while (iterator.hasNext()) {
		String key = iterator.next();
		Integer value = map.get(key);
		System.out.println("\t" + key + ": " + value);
	}
	System.out.println();

	// 4. 객체 삭제
	map.remove("홍길동");
	System.out.println("총 Entry 수: " + map.size());

	// 5. 객체를 하나씩 처리
	Set<Map.Entry<String, Integer>> entrySet = map.entrySet(); // Map.EntrySet 얻기
	for (Map.Entry<String, Integer> entry : entrySet) {
		String key = entry.getKey();
		Integer value = entry.getValue();
		System.out.println("\t" + key + ": " + value);
	}
	System.out.println();

// 6. 모든 Map.Entry 삭제
	map.clear();
	System.out.println("총 Entry 수: " + map.size());
}

}

<실행결과>

```java
총 Entry 수: 3
	홍길동: 80

	제시카: 95
	홍길동: 80
	카리나: 85

총 Entry 수: 2
	제시카: 95
	카리나: 85

총 Entry 수: 0

다음 예제는 사용자 정의 객체인 Student를 Key로 하고 Value로는 점수를 저장하는 HashMap을 구현해보겠습니다.

public class Student {
	private int no;
	private String name;

	public Student(int no, String name) {
		this.no = no;
		this.name = name;
	}

	@Override
	public boolean equals(Object obj) {  // 학번과 이름이 동일할 경우 true
		if (obj instanceof Student) {
			Student student = (Student)obj;
			return (no == student.no) && (name.equals(student.name));
		}
		return false;
	}

	@Override
	public int hashCode() {     // 학번과 이름이 같다면 동일한 값을 리턴
		return no + name.hashCode();
	}
}

import java.util.HashMap;
import java.util.Map;

public class HashMapExample2 {
	public static void main(String[] args) {
		Map<Student, Integer> map = new HashMap<>();

		map.put(new Student(50, "홍길동"), 95);        // 학번과 이름이 동일한 Student를 키로 저장
		map.put(new Student(50, "홍길동"), 95);

		System.out.println("총 Entry 수: " + map.size());    // 저장된 총 Map.Entry 수 얻기
	}
}

<실행결과>

총 Entry 수: 1

Hashtable

HashMap과 동일한 내부 구조를 가진 Hashtable에 대해서 알아봅시다. HashMap과의 가장 큰 차이점이라면 Hashtable은 동기화된(synchronized) 메소드로 구성되어 있기 때문에 멀티 스레드가 동시에 이 메소드를 실행할 수 없고, 하나의 스레드가 실행을 완료해야 다른 스레드를 실행할 수 있습니다. 그래서 멀티 스레드 환경에서 안전하게 객체를 추가, 삭제할 수 있는 특징을 갖고있습니다. 이것을 thread safe 하다라고 말합니다.

Hashtable의 생성 방법은 HashMap과 크게 다르지 않은데요, 키 타입과 값 타입을 지정하고 기본 생성자를 호출하면 됩니다.

다음은 키보드로 아이디와 비밀번호를 입력받아서, Hashtable에 저장된 키(아이디)와 값(비밀번호)으로 비교한 후 로그인 여부를 출력하는 예제입니다.

package Chapter12.hashtable;

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("taeyuniya12", "rladbs12!@");
      map.put("kkunh97", "rjsgur12!@");
      map.put("dlawhdfbf12", "rornf713!@");
      map.put("qkrwlstjd", "qkrwls12!@");

      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();
          System.out.println();

          if (map.containsKey(id)) {
              if (map.get(id).equals(password)) {
                  System.out.println("로그인이 되었습니다");
                  break;
              } else {
                  System.out.println("비밀번호가 일치하지 않습니다!");
              }
          } else {
              System.out.println("입력하신 아이디가 존재하지 않습니다!\n");
          }
      }


  }
}

<실행결과>

🧱 LIFO , FIFO 컬렉션 - Stack과 Queue

후입선출 (LIFO: Last In First Out)은 나중에 넣은 객체가 먼저 빠져나가는 자료구조를 말합니다. 반대로 선입선출(First In First Out)은 먼저 넣은 객체가 먼저 빠져나가는 구조를 말합니다. 컬렉션 프레임워크 에서는 후입선출(LIFO) 자료구조를 제공해주는 Stack, 선입선출(FIFO) 자료구조를 제공해주는 Queue 인터페이스가 있습니다.

Stack

Queue

Stack (후입선출, LIFO)

스택은 마지막에 넣은 객체가 가장 먼저 빠지는 자료구조입니다. 다음 그림으로 스택의 자료구조를 이해해볼게요. 과거에 택시에서 주로 볼 수 있었던 동전케이스인데, 이 케이스에서 동전을 넣고, 뺄 수 있는 데이터의 구조가 바로 스택 구조입니다. 스택 구조에서 맨 처음에 넣은 동전은 맨 나중에 뺄 수가 있습니다. (LIFO)

Stack 클래스는 LIFO 자료구조를 구현한 클래스 이고, 다음 표로 Stack 클래스의 주요 메소드들을 보시죠.

리턴 타입	메소드	설명
E	push(E item)	주어진 객체를 스택에 넣는다
E	peek()	스택의 맨 위 객체를 가져온다. 객체를 스택에서 제거하지 않는다.
E	pop()	스택의 맨 위 객체를 가져오고, 객체를 스택에서 제거한다.

Stack 객체를 생성하기 위해서는 저장할 객체 타입을 파라미터로 표기하고 기본 생성자를 호출하면 됩니다.

Stack<E> stack = new Stack<E>();

package Chapter13;

import java.util.Stack;

public class StackExample {
  public static void main(String[] args) {
      Stack<String> stack = new Stack<>();
      stack.push("비트코인");
      stack.push("이더리움");
      stack.push("에이다");
      stack.push("솔라나");

      System.out.println(stack.peek()); //paek과 pop의 차이는 뭘까요?
      System.out.println(stack.peek());
      System.out.println(stack.peek());
      System.out.println(stack.peek());

      System.out.println("- - - - - -");

      System.out.println(stack.pop());
      System.out.println(stack.pop());
      System.out.println(stack.pop());
      System.out.println(stack.pop());
  }
}

실행 결과는 이렇습니다.

Queue (선입선출, FIFO)

큐는 앞서 들어간 데이터가 먼저 출력이 되는 자료구조입니다. 흔히 우리가 지하철을 기다리려고 줄을 섰을 때, 먼저 줄을 선 사람이 지하철에 먼저 타게되는 형태이죠.

다음 그림으로 큐의 자료구조를 알아보겠습니다.

Queue 인터페이스는 이런 FIFO 자료구조에서 사용되는 메소드를 정의하고 있습니다. 다음 표에서 Queue 인터페이스에 정의되어 있는 메소드를 보겠습니다.

리턴 타입	메소드	설명
boolean	offer(E e)	주어진 객체를 넣는다.
E	peek()	객체 하나를 가져온다. 객체를 큐에서 제거하지 않는다.
E	poll()	객체 하나를 가져온다. 객체를 큐에서 제거한다.

Queue 인터페이스를 구현한 대표적인 클래스는 LinkedList 입니다.

LinkedList는 List 인터페이스를 구현했기 때문에 List 컬렉션이기도 합니다. 다음 코드는 LinkedList 객체를 Queue 인터페이스 타입으로 변환한 것 입니다.

Queue<E> queue = new LinkedList<E>();

다음은 Queue를 이용해서 간단한 메시지 큐를 구현한 예제입니다. 먼저 넣은 메시지가 반대쪽으로 먼저 나오기 때문에 넣은 순서대로 메시지가 처리가됩니다. 코드를 보며 실행결과를 유추해보시고, 코드를 직접 작성해보면서 실행결과와 같은 출력을 하도록 해봅시다.

public class Message {
	private String command;
	private String to;

	public String getCommand() {
		return command;
	}

	public String getTo() {
		return to;
	}

	public Message(String command, String to) {
		this.command = command;
		this.to = to;
	}
}

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

public class QueueExample {
	public static void main(String[] args) {
		Queue<Message> messageQueue = new LinkedList<>();

		messageQueue.offer(new Message("sendMail", "홍길동"));
		messageQueue.offer(new Message("sendSms", "제니"));
		messageQueue.offer(new Message("sendKakaoTalk", "리사"));

		while (!messageQueue.isEmpty()) {        // 메시지 큐가 비었는지 확인 
			Message message = messageQueue.poll(); // 메시지 큐에서 하나의 메시지 꺼냄
			switch (message.getCommand()) {
				case "sendMail":
					System.out.println(message.getTo() + "에게 메일을 보냅니다.");
					break;
				case "sendSms":
					System.out.println(message.getTo() + "에게 SMS를 보냅니다.");
					break;
				case "sendKakaoTalk":
					System.out.println(message.getTo() + "에게 카톡을 보냅니다.");
					break;
			}
		}
	}
}

<실행결과>

홍길동에게 메일을 보냅니다.
제니에게 SMS를 보냅니다.
리사에게 카톡을 보냅니다.