반응형
Java 컬렉션 프레임워크(Collection Framework) 복습
이 문서는 Java의 컬렉션 프레임워크의 핵심 인터페이스인 List, Set, Map에 대한 개념을 정리하고, 간단한 예제를 통해 사용법을 복습하는 것을 목표로 합니다.
1. 컬렉션 프레임워크란?
- 컬렉션(Collection): 데이터의 집합 또는 그룹
- 프레임워크(Framework): 작업을 위한 표준화된 틀
- 즉, 데이터 그룹을 저장하고 관리하기 위한 표준화된 클래스들의 집합입니다. 자료구조 및 알고리즘을 구현해 놓은 라이브러리로, 개발자가 더 쉽게 데이터를 처리할 수 있도록 돕습니다.
주요 인터페이스
- List: 순서가 있는 데이터의 집합. 데이터 중복을 허용합니다.
- Set: 순서가 없는 데이터의 집합. 데이터 중복을 허용하지 않습니다.
- Map: 키(Key)와 값(Value)의 쌍으로 이루어진 데이터의 집합. 키는 중복될 수 없지만, 값은 중복될 수 있습니다.
2. List 인터페이스
List는 순서가 있는 데이터 컬렉션으로, 인덱스를 통해 데이터에 접근할 수 있습니다. 데이터의 중복 저장을 허용합니다.
주요 구현 클래스
- ArrayList: 배열 기반의 리스트. 데이터 조회(get)가 빠르지만, 데이터 추가/삭제 시 성능 저하가 발생할 수 있습니다. (비동기)
- LinkedList: 연결(link) 기반의 리스트. 데이터 추가/삭제가 빠르지만, 데이터 조회 시 성능이 ArrayList보다 느릴 수 있습니다.
- Vector: ArrayList와 유사하지만, 동기화(synchronization)를 지원하여 멀티스레드 환경에서 안전하게 사용할 수 있습니다.
주요 메소드
- add(E element): 리스트의 끝에 요소를 추가합니다.
- add(int index, E element): 지정된 인덱스에 요소를 추가합니다.
- get(int index): 지정된 인덱스의 요소를 반환합니다.
- set(int index, E element): 지정된 인덱스의 요소를 새로운 요소로 변경합니다.
- remove(int index): 지정된 인덱스의 요소를 삭제합니다.
- size(): 리스트의 크기(요소의 개수)를 반환합니다.
- contains(Object o): 리스트에 특정 요소가 포함되어 있는지 확인합니다.
- clear(): 리스트의 모든 요소를 삭제합니다.
- isEmpty(): 리스트가 비어있는지 확인합니다.
예제 코드
import java.util.ArrayList;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
// ArrayList 생성 (다형성)
List<String> names = new ArrayList<>();
// 1. 데이터 추가 (add)
names.add("유재석");
names.add("강호동");
names.add("신동엽");
names.add(1, "서장훈"); // 1번 인덱스에 "서장훈" 추가
System.out.println("전체 리스트: " + names); // [유재석, 서장훈, 강호동, 신동엽]
// 2. 데이터 조회 (get)
String name = names.get(2);
System.out.println("2번 인덱스: " + name); // 강호동
// 3. 데이터 개수 (size)
System.out.println("리스트 크기: " + names.size()); // 4
// 4. 데이터 수정 (set)
names.set(0, "유느님");
System.out.println("수정 후 리스트: " + names); // [유느님, 서장훈, 강호동, 신동엽]
// 5. 데이터 삭제 (remove)
names.remove(1); // 1번 인덱스 "서장훈" 삭제
System.out.println("삭제 후 리스트: " + names); // [유느님, 강호동, 신동엽]
// 6. 반복문으로 전체 요소 출력
System.out.println("--- 전체 요소 출력 ---");
for (String s : names) {
System.out.println(s);
}
}
}
3. Set 인터페이스
Set은 순서가 보장되지 않는 데이터의 집합이며, 가장 큰 특징은 데이터 중복을 허용하지 않는다는 것입니다.
주요 구현 클래스
- HashSet: 가장 일반적인 Set 구현체. 순서를 보장하지 않으며, 해시(hash)를 사용하여 데이터를 저장하므로 검색 속도가 빠릅니다.
- TreeSet: 정렬된 순서대로 데이터를 저장하는 Set 구현체. 데이터를 추가할 때 자동으로 오름차순 정렬됩니다.
- LinkedHashSet: 추가된 순서대로 데이터를 저장하는 Set 구현체입니다.
주요 메소드
Set은 인덱스가 없으므로 get(), set() 메소드가 없습니다.
- add(E element): 집합에 요소를 추가합니다. (중복 시 추가되지 않음)
- remove(Object o): 집합에서 특정 요소를 삭제합니다.
- size(): 집합의 크기를 반환합니다.
- contains(Object o): 집합에 특정 요소가 포함되어 있는지 확인합니다.
- clear(): 집합의 모든 요소를 삭제합니다.
- isEmpty(): 집합이 비어있는지 확인합니다.
예제 코드
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class SetExample {
public static void main(String[] args) {
// HashSet 생성
Set<String> languages = new HashSet<>();
// 1. 데이터 추가 (add)
languages.add("Java");
languages.add("Python");
languages.add("C++");
boolean isAdded = languages.add("Java"); // 중복된 데이터 추가 시도
System.out.println("전체 집합: " + languages); // [Java, Python, C++] (순서 보장 안됨)
System.out.println("중복 데이터 추가 성공 여부: " + isAdded); // false
// 2. 데이터 포함 여부 (contains)
System.out.println("Python 포함 여부: " + languages.contains("Python")); // true
// 3. 데이터 삭제 (remove)
languages.remove("C++");
System.out.println("삭제 후 집합: " + languages); // [Java, Python]
// 4. 반복문으로 전체 요소 출력
System.out.println("--- 전체 요소 출력 ---");
for (String lang : languages) {
System.out.println(lang);
}
// TreeSet 예제 (자동 정렬)
Set<Integer> numbers = new TreeSet<>();
numbers.add(30);
numbers.add(10);
numbers.add(20);
System.out.println("TreeSet (자동 정렬): " + numbers); // [10, 20, 30]
}
}
4. Map 인터페이스
Map은 키(Key)와 값(Value)을 하나의 쌍(Entry)으로 묶어서 관리하는 데이터 구조입니다. 키는 고유해야 하며(중복 불가), 값은 중복될 수 있습니다.
주요 구현 클래스
- HashMap: 가장 일반적인 Map 구현체. 순서를 보장하지 않으며, key에 null을 허용합니다. (비동기)
- Hashtable: HashMap과 유사하지만, 동기화를 지원하여 멀티스레드 환경에서 안전합니다. key에 null을 허용하지 않습니다.
- TreeMap: 키(key)를 기준으로 자동 정렬(오름차순)되는 Map 구현체입니다.
- Properties: <String, String> 형태를 가지는 Map. 주로 설정 파일의 내용을 읽고 쓰는 데 사용됩니다.
주요 메소드
- put(K key, V value): 맵에 키와 값의 쌍(Entry)을 추가합니다. 동일한 키가 존재하면 값을 덮어씁니다.
- get(Object key): 주어진 키에 해당하는 값을 반환합니다.
- remove(Object key): 주어진 키에 해당하는 엔트리를 삭제합니다.
- size(): 맵의 엔트리 개수를 반환합니다.
- containsKey(Object key): 맵에 특정 키가 포함되어 있는지 확인합니다.
- containsValue(Object value): 맵에 특정 값이 포함되어 있는지 확인합니다.
- keySet(): 맵의 모든 키를 Set 형태로 반환합니다.
- values(): 맵의 모든 값을 Collection 형태로 반환합니다.
- entrySet(): 맵의 모든 엔트리(Map.Entry)를 Set 형태로 반환합니다.
예제 코드
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapExample {
public static void main(String[] args) {
// HashMap 생성
Map<String, Integer> scores = new HashMap<>();
// 1. 데이터 추가 (put)
scores.put("유재석", 95);
scores.put("강호동", 100);
scores.put("신동엽", 88);
scores.put("유재석", 92); // 동일한 키에 값을 넣으면 덮어쓴다.
System.out.println("전체 맵: " + scores); // {강호동=100, 신동엽=88, 유재석=92}
// 2. 데이터 조회 (get)
int score = scores.get("강호동");
System.out.println("강호동의 점수: " + score); // 100
// 3. 데이터 삭제 (remove)
scores.remove("신동엽");
System.out.println("삭제 후 맵: " + scores); // {강호동=100, 유재석=92}
// 4. 반복문으로 전체 요소 출력 (keySet 사용)
System.out.println("--- 전체 요소 출력 ---");
Set<String> keys = scores.keySet(); // 모든 키를 Set으로 가져온다.
for (String key : keys) {
System.out.println("이름: " + key + ", 점수: " + scores.get(key));
}
}
}Java 컬렉션 프레임워크(Collection Framework) 복습
이 문서는 Java의 컬렉션 프레임워크의 핵심 인터페이스인 List, Set, Map에 대한 개념을 정리하고, 간단한 예제를 통해 사용법을 복습하는 것을 목표로 합니다.
1. 컬렉션 프레임워크란?
- 컬렉션(Collection): 데이터의 집합 또는 그룹
- 프레임워크(Framework): 작업을 위한 표준화된 틀
- 즉, 데이터 그룹을 저장하고 관리하기 위한 표준화된 클래스들의 집합입니다. 자료구조 및 알고리즘을 구현해 놓은 라이브러리로, 개발자가 더 쉽게 데이터를 처리할 수 있도록 돕습니다.
주요 인터페이스
- List: 순서가 있는 데이터의 집합. 데이터 중복을 허용합니다.
- Set: 순서가 없는 데이터의 집합. 데이터 중복을 허용하지 않습니다.
- Map: 키(Key)와 값(Value)의 쌍으로 이루어진 데이터의 집합. 키는 중복될 수 없지만, 값은 중복될 수 있습니다.
2. List 인터페이스
List는 순서가 있는 데이터 컬렉션으로, 인덱스를 통해 데이터에 접근할 수 있습니다. 데이터의 중복 저장을 허용합니다.
주요 구현 클래스
- ArrayList: 배열 기반의 리스트. 데이터 조회(get)가 빠르지만, 데이터 추가/삭제 시 성능 저하가 발생할 수 있습니다. (비동기)
- LinkedList: 연결(link) 기반의 리스트. 데이터 추가/삭제가 빠르지만, 데이터 조회 시 성능이 ArrayList보다 느릴 수 있습니다.
- Vector: ArrayList와 유사하지만, 동기화(synchronization)를 지원하여 멀티스레드 환경에서 안전하게 사용할 수 있습니다.
주요 메소드
- add(E element): 리스트의 끝에 요소를 추가합니다.
- add(int index, E element): 지정된 인덱스에 요소를 추가합니다.
- get(int index): 지정된 인덱스의 요소를 반환합니다.
- set(int index, E element): 지정된 인덱스의 요소를 새로운 요소로 변경합니다.
- remove(int index): 지정된 인덱스의 요소를 삭제합니다.
- size(): 리스트의 크기(요소의 개수)를 반환합니다.
- contains(Object o): 리스트에 특정 요소가 포함되어 있는지 확인합니다.
- clear(): 리스트의 모든 요소를 삭제합니다.
- isEmpty(): 리스트가 비어있는지 확인합니다.
예제 코드
import java.util.ArrayList;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
// ArrayList 생성 (다형성)
List<String> names = new ArrayList<>();
// 1. 데이터 추가 (add)
names.add("유재석");
names.add("강호동");
names.add("신동엽");
names.add(1, "서장훈"); // 1번 인덱스에 "서장훈" 추가
System.out.println("전체 리스트: " + names); // [유재석, 서장훈, 강호동, 신동엽]
// 2. 데이터 조회 (get)
String name = names.get(2);
System.out.println("2번 인덱스: " + name); // 강호동
// 3. 데이터 개수 (size)
System.out.println("리스트 크기: " + names.size()); // 4
// 4. 데이터 수정 (set)
names.set(0, "유느님");
System.out.println("수정 후 리스트: " + names); // [유느님, 서장훈, 강호동, 신동엽]
// 5. 데이터 삭제 (remove)
names.remove(1); // 1번 인덱스 "서장훈" 삭제
System.out.println("삭제 후 리스트: " + names); // [유느님, 강호동, 신동엽]
// 6. 반복문으로 전체 요소 출력
System.out.println("--- 전체 요소 출력 ---");
for (String s : names) {
System.out.println(s);
}
}
}
3. Set 인터페이스
Set은 순서가 보장되지 않는 데이터의 집합이며, 가장 큰 특징은 데이터 중복을 허용하지 않는다는 것입니다.
주요 구현 클래스
- HashSet: 가장 일반적인 Set 구현체. 순서를 보장하지 않으며, 해시(hash)를 사용하여 데이터를 저장하므로 검색 속도가 빠릅니다.
- TreeSet: 정렬된 순서대로 데이터를 저장하는 Set 구현체. 데이터를 추가할 때 자동으로 오름차순 정렬됩니다.
- LinkedHashSet: 추가된 순서대로 데이터를 저장하는 Set 구현체입니다.
주요 메소드
Set은 인덱스가 없으므로 get(), set() 메소드가 없습니다.
- add(E element): 집합에 요소를 추가합니다. (중복 시 추가되지 않음)
- remove(Object o): 집합에서 특정 요소를 삭제합니다.
- size(): 집합의 크기를 반환합니다.
- contains(Object o): 집합에 특정 요소가 포함되어 있는지 확인합니다.
- clear(): 집합의 모든 요소를 삭제합니다.
- isEmpty(): 집합이 비어있는지 확인합니다.
예제 코드
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class SetExample {
public static void main(String[] args) {
// HashSet 생성
Set<String> languages = new HashSet<>();
// 1. 데이터 추가 (add)
languages.add("Java");
languages.add("Python");
languages.add("C++");
boolean isAdded = languages.add("Java"); // 중복된 데이터 추가 시도
System.out.println("전체 집합: " + languages); // [Java, Python, C++] (순서 보장 안됨)
System.out.println("중복 데이터 추가 성공 여부: " + isAdded); // false
// 2. 데이터 포함 여부 (contains)
System.out.println("Python 포함 여부: " + languages.contains("Python")); // true
// 3. 데이터 삭제 (remove)
languages.remove("C++");
System.out.println("삭제 후 집합: " + languages); // [Java, Python]
// 4. 반복문으로 전체 요소 출력
System.out.println("--- 전체 요소 출력 ---");
for (String lang : languages) {
System.out.println(lang);
}
// TreeSet 예제 (자동 정렬)
Set<Integer> numbers = new TreeSet<>();
numbers.add(30);
numbers.add(10);
numbers.add(20);
System.out.println("TreeSet (자동 정렬): " + numbers); // [10, 20, 30]
}
}
4. Map 인터페이스
Map은 키(Key)와 값(Value)을 하나의 쌍(Entry)으로 묶어서 관리하는 데이터 구조입니다. 키는 고유해야 하며(중복 불가), 값은 중복될 수 있습니다.
주요 구현 클래스
- HashMap: 가장 일반적인 Map 구현체. 순서를 보장하지 않으며, key에 null을 허용합니다. (비동기)
- Hashtable: HashMap과 유사하지만, 동기화를 지원하여 멀티스레드 환경에서 안전합니다. key에 null을 허용하지 않습니다.
- TreeMap: 키(key)를 기준으로 자동 정렬(오름차순)되는 Map 구현체입니다.
- Properties: <String, String> 형태를 가지는 Map. 주로 설정 파일의 내용을 읽고 쓰는 데 사용됩니다.
주요 메소드
- put(K key, V value): 맵에 키와 값의 쌍(Entry)을 추가합니다. 동일한 키가 존재하면 값을 덮어씁니다.
- get(Object key): 주어진 키에 해당하는 값을 반환합니다.
- remove(Object key): 주어진 키에 해당하는 엔트리를 삭제합니다.
- size(): 맵의 엔트리 개수를 반환합니다.
- containsKey(Object key): 맵에 특정 키가 포함되어 있는지 확인합니다.
- containsValue(Object value): 맵에 특정 값이 포함되어 있는지 확인합니다.
- keySet(): 맵의 모든 키를 Set 형태로 반환합니다.
- values(): 맵의 모든 값을 Collection 형태로 반환합니다.
- entrySet(): 맵의 모든 엔트리(Map.Entry)를 Set 형태로 반환합니다.
예제 코드
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapExample {
public static void main(String[] args) {
// HashMap 생성
Map<String, Integer> scores = new HashMap<>();
// 1. 데이터 추가 (put)
scores.put("유재석", 95);
scores.put("강호동", 100);
scores.put("신동엽", 88);
scores.put("유재석", 92); // 동일한 키에 값을 넣으면 덮어쓴다.
System.out.println("전체 맵: " + scores); // {강호동=100, 신동엽=88, 유재석=92}
// 2. 데이터 조회 (get)
int score = scores.get("강호동");
System.out.println("강호동의 점수: " + score); // 100
// 3. 데이터 삭제 (remove)
scores.remove("신동엽");
System.out.println("삭제 후 맵: " + scores); // {강호동=100, 유재석=92}
// 4. 반복문으로 전체 요소 출력 (keySet 사용)
System.out.println("--- 전체 요소 출력 ---");
Set<String> keys = scores.keySet(); // 모든 키를 Set으로 가져온다.
for (String key : keys) {
System.out.println("이름: " + key + ", 점수: " + scores.get(key));
}
}
}Java 컬렉션 프레임워크(Collection Framework) 복습
이 문서는 Java의 컬렉션 프레임워크의 핵심 인터페이스인 List, Set, Map에 대한 개념을 정리하고, 간단한 예제를 통해 사용법을 복습하는 것을 목표로 합니다.
1. 컬렉션 프레임워크란?
- 컬렉션(Collection): 데이터의 집합 또는 그룹
- 프레임워크(Framework): 작업을 위한 표준화된 틀
- 즉, 데이터 그룹을 저장하고 관리하기 위한 표준화된 클래스들의 집합입니다. 자료구조 및 알고리즘을 구현해 놓은 라이브러리로, 개발자가 더 쉽게 데이터를 처리할 수 있도록 돕습니다.
주요 인터페이스
- List: 순서가 있는 데이터의 집합. 데이터 중복을 허용합니다.
- Set: 순서가 없는 데이터의 집합. 데이터 중복을 허용하지 않습니다.
- Map: 키(Key)와 값(Value)의 쌍으로 이루어진 데이터의 집합. 키는 중복될 수 없지만, 값은 중복될 수 있습니다.
2. List 인터페이스
List는 순서가 있는 데이터 컬렉션으로, 인덱스를 통해 데이터에 접근할 수 있습니다. 데이터의 중복 저장을 허용합니다.
주요 구현 클래스
- ArrayList: 배열 기반의 리스트. 데이터 조회(get)가 빠르지만, 데이터 추가/삭제 시 성능 저하가 발생할 수 있습니다. (비동기)
- LinkedList: 연결(link) 기반의 리스트. 데이터 추가/삭제가 빠르지만, 데이터 조회 시 성능이 ArrayList보다 느릴 수 있습니다.
- Vector: ArrayList와 유사하지만, 동기화(synchronization)를 지원하여 멀티스레드 환경에서 안전하게 사용할 수 있습니다.
주요 메소드
- add(E element): 리스트의 끝에 요소를 추가합니다.
- add(int index, E element): 지정된 인덱스에 요소를 추가합니다.
- get(int index): 지정된 인덱스의 요소를 반환합니다.
- set(int index, E element): 지정된 인덱스의 요소를 새로운 요소로 변경합니다.
- remove(int index): 지정된 인덱스의 요소를 삭제합니다.
- size(): 리스트의 크기(요소의 개수)를 반환합니다.
- contains(Object o): 리스트에 특정 요소가 포함되어 있는지 확인합니다.
- clear(): 리스트의 모든 요소를 삭제합니다.
- isEmpty(): 리스트가 비어있는지 확인합니다.
예제 코드
import java.util.ArrayList;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
// ArrayList 생성 (다형성)
List<String> names = new ArrayList<>();
// 1. 데이터 추가 (add)
names.add("유재석");
names.add("강호동");
names.add("신동엽");
names.add(1, "서장훈"); // 1번 인덱스에 "서장훈" 추가
System.out.println("전체 리스트: " + names); // [유재석, 서장훈, 강호동, 신동엽]
// 2. 데이터 조회 (get)
String name = names.get(2);
System.out.println("2번 인덱스: " + name); // 강호동
// 3. 데이터 개수 (size)
System.out.println("리스트 크기: " + names.size()); // 4
// 4. 데이터 수정 (set)
names.set(0, "유느님");
System.out.println("수정 후 리스트: " + names); // [유느님, 서장훈, 강호동, 신동엽]
// 5. 데이터 삭제 (remove)
names.remove(1); // 1번 인덱스 "서장훈" 삭제
System.out.println("삭제 후 리스트: " + names); // [유느님, 강호동, 신동엽]
// 6. 반복문으로 전체 요소 출력
System.out.println("--- 전체 요소 출력 ---");
for (String s : names) {
System.out.println(s);
}
}
}
3. Set 인터페이스
Set은 순서가 보장되지 않는 데이터의 집합이며, 가장 큰 특징은 데이터 중복을 허용하지 않는다는 것입니다.
주요 구현 클래스
- HashSet: 가장 일반적인 Set 구현체. 순서를 보장하지 않으며, 해시(hash)를 사용하여 데이터를 저장하므로 검색 속도가 빠릅니다.
- TreeSet: 정렬된 순서대로 데이터를 저장하는 Set 구현체. 데이터를 추가할 때 자동으로 오름차순 정렬됩니다.
- LinkedHashSet: 추가된 순서대로 데이터를 저장하는 Set 구현체입니다.
주요 메소드
Set은 인덱스가 없으므로 get(), set() 메소드가 없습니다.
- add(E element): 집합에 요소를 추가합니다. (중복 시 추가되지 않음)
- remove(Object o): 집합에서 특정 요소를 삭제합니다.
- size(): 집합의 크기를 반환합니다.
- contains(Object o): 집합에 특정 요소가 포함되어 있는지 확인합니다.
- clear(): 집합의 모든 요소를 삭제합니다.
- isEmpty(): 집합이 비어있는지 확인합니다.
예제 코드
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class SetExample {
public static void main(String[] args) {
// HashSet 생성
Set<String> languages = new HashSet<>();
// 1. 데이터 추가 (add)
languages.add("Java");
languages.add("Python");
languages.add("C++");
boolean isAdded = languages.add("Java"); // 중복된 데이터 추가 시도
System.out.println("전체 집합: " + languages); // [Java, Python, C++] (순서 보장 안됨)
System.out.println("중복 데이터 추가 성공 여부: " + isAdded); // false
// 2. 데이터 포함 여부 (contains)
System.out.println("Python 포함 여부: " + languages.contains("Python")); // true
// 3. 데이터 삭제 (remove)
languages.remove("C++");
System.out.println("삭제 후 집합: " + languages); // [Java, Python]
// 4. 반복문으로 전체 요소 출력
System.out.println("--- 전체 요소 출력 ---");
for (String lang : languages) {
System.out.println(lang);
}
// TreeSet 예제 (자동 정렬)
Set<Integer> numbers = new TreeSet<>();
numbers.add(30);
numbers.add(10);
numbers.add(20);
System.out.println("TreeSet (자동 정렬): " + numbers); // [10, 20, 30]
}
}
4. Map 인터페이스
Map은 키(Key)와 값(Value)을 하나의 쌍(Entry)으로 묶어서 관리하는 데이터 구조입니다. 키는 고유해야 하며(중복 불가), 값은 중복될 수 있습니다.
주요 구현 클래스
- HashMap: 가장 일반적인 Map 구현체. 순서를 보장하지 않으며, key에 null을 허용합니다. (비동기)
- Hashtable: HashMap과 유사하지만, 동기화를 지원하여 멀티스레드 환경에서 안전합니다. key에 null을 허용하지 않습니다.
- TreeMap: 키(key)를 기준으로 자동 정렬(오름차순)되는 Map 구현체입니다.
- Properties: <String, String> 형태를 가지는 Map. 주로 설정 파일의 내용을 읽고 쓰는 데 사용됩니다.
주요 메소드
- put(K key, V value): 맵에 키와 값의 쌍(Entry)을 추가합니다. 동일한 키가 존재하면 값을 덮어씁니다.
- get(Object key): 주어진 키에 해당하는 값을 반환합니다.
- remove(Object key): 주어진 키에 해당하는 엔트리를 삭제합니다.
- size(): 맵의 엔트리 개수를 반환합니다.
- containsKey(Object key): 맵에 특정 키가 포함되어 있는지 확인합니다.
- containsValue(Object value): 맵에 특정 값이 포함되어 있는지 확인합니다.
- keySet(): 맵의 모든 키를 Set 형태로 반환합니다.
- values(): 맵의 모든 값을 Collection 형태로 반환합니다.
- entrySet(): 맵의 모든 엔트리(Map.Entry)를 Set 형태로 반환합니다.
예제 코드
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapExample {
public static void main(String[] args) {
// HashMap 생성
Map<String, Integer> scores = new HashMap<>();
// 1. 데이터 추가 (put)
scores.put("유재석", 95);
scores.put("강호동", 100);
scores.put("신동엽", 88);
scores.put("유재석", 92); // 동일한 키에 값을 넣으면 덮어쓴다.
System.out.println("전체 맵: " + scores); // {강호동=100, 신동엽=88, 유재석=92}
// 2. 데이터 조회 (get)
int score = scores.get("강호동");
System.out.println("강호동의 점수: " + score); // 100
// 3. 데이터 삭제 (remove)
scores.remove("신동엽");
System.out.println("삭제 후 맵: " + scores); // {강호동=100, 유재석=92}
// 4. 반복문으로 전체 요소 출력 (keySet 사용)
System.out.println("--- 전체 요소 출력 ---");
Set<String> keys = scores.keySet(); // 모든 키를 Set으로 가져온다.
for (String key : keys) {
System.out.println("이름: " + key + ", 점수: " + scores.get(key));
}
}
}package day23; // package name
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;
public class Example1 {
public static void main(String[] args) {
/*
인터페이스 : 추상메소드를 가진 타입
추상메소드 : 선언만 하고 구현부{}를 정의하지 않은 메소드
구현체 : 추상메소드를 가진 인터페이스를 implements 해서 추상메소드를 구현한 클래스의 객체
** 다형성 ** : 다양한 타입을 가지는 성질 , extends / implements 키워드 구조관계
[ 컬렉션 프레임워크 ]
- 컬렉션(수집) 프레임(틀) 워크(작업) : 자료 수집(=자료구조) 방법
- 종류 : List , Set , Map 인터페이스
- 구현체 :
1) List : ArrayList , Vector , LinkedList 등
.add( 자료 )
2) Set : HashSet , TreeSet 등
3) Map : HashMap , TableMap 등
*/
// [1] 인터페이스타입 변수명 = new 클래스명();
// ArrayList<> 대신 List<> 가능
ArrayList< String > list1 = new ArrayList<>(); // (1)
List< String > list2 = new ArrayList<>(); // (2)
// [2] List 인터페이스 주요 메소드
// 1) .add( 자료 ) : 리스트내 지정한 자료를 마지막 요소 추가
list2.add("유재석");
list2.add("강호동");
list2.add("신동엽");
list2.add("유재석"); // 중복허용
list2.add( 2 , "서장훈"); // 리스트내 지정한 인덱스의 자료를 추가
System.out.println(list2); // [유재석, 강호동, 서장훈, 신동엽, 유재석]
// 2) .set( 인덱스 , 자료 ) : 리스트내 지정한 인덱스의 자료를 수정/변경
list2.set( 0 , "유재석2");
System.out.println(list2); // [유재석2, 강호동, 서장훈, 신동엽, 유재석]
// 3) .get( 인덱스 ) : 리스트내 지정한 인덱스 자료 호출/반환
String result = list2.get( 2 );
System.out.println(result); // 서장훈
// 4) .size() : 리스트내 전체 요소/자료 개수 반환
int count = list2.size();
System.out.println(count); // 5개의 요소가 있어서 5 나옴
// 5) .contains( 자료 ) : 리스트내 지정한 자료 존재하면 true, 없으면 false
boolean bool = list2.contains("서장훈");
System.out.println(bool); // 서장훈 있으면 true
// 6) .indexOf( 자료 ) : 리스트내 지정한 자료의 인덱스 반환, 없으면 -1
int index = list2.indexOf("서장훈");
System.out.println(index); // 서장훈이 세 번째 인덱스에 있으므로 2 반환
// 7) .remove( 인덱스 ) : 리스트내 지정한 인덱스의 요소/항목/자료 삭제
list2.remove(2); // 2번(서장훈) 삭제
System.out.println(list2); // [유재석2, 강호동, 신동엽, 유재석]
// 8) .isEmpty() : 리스트내 요소가 비어있으면 true , 1개이상 존재하면 false
System.out.println(list2.isEmpty()); // 비어있지 않아서 false
// 9) .clear() : 리스트내 모든 요소 삭제
// list2.clear();
// System.out.println(list2); // [] 빈 배열 남음
// 10) 리스트/배열와 반복문 활용
// 리스트( 여러가지 자료(객체)들을 갖는 자료(객체) )
// 여러가지 자료들을 순서대로 호출/순회/확인 == 반복문 통해 작업
// (1) 일반 for문
for( int i = 0; i < list2.size(); i++){
System.out.println(list2.get(i));
} // for end
// (2) 향상된 for문
for (String str : list2){
System.out.println(str);
} // for end 인덱스 필요없으면 이거 쓰기
// (3) forEach문 : 리스트내 첫번째 요소부터 마지막 요소까지 *순서대로* 반복변수에 대입하여 실행처리한다.
// 리스트/배열명.forEach( )
// list2.forEach( (반복변수) -> {실행문} );
// 람다식/화살표 함수 : 복잡한 메소드 선언 방식을 간소화 , ( 매개변수 ) -> { 실행문 }
list2.forEach(str -> {
System.out.println( str );
});
list2.forEach((str) -> {
System.out.println(list1); // list2의 배열 숫자인 4번만큼 list1의 []빈배열 출력
});
// ------------------------------------------------------------------------ //
// List : 순서대로 요소 저장하는 자료구조
// ArrayList : 배열 구조로 사용되는 List 구현체 + 메소드 비동기화( 단일 스레드 플랫폼 )
ArrayList< Integer > arrayList = new ArrayList<>();
// Vector : 배열 구조로 사용되는 List 구현체 + 메소드가 동기화 처리됨 ( 멀티 스레드 플랫폼 )
Vector< Integer > vector = new Vector<>();
// LinkedList : 링크(체인/꼬리연결) 구조로 사용되는 List 구현체 + 중간 삽입/삭제 효율성 극대화
// 배열구조 : [ 5 ] [ 4 ] [ 7 ] [ 10 ]
// 0 1 2 3
// 만약 1번 인덱스가 삭제되면 2, 3번 인덱스는 한칸씩 앞으로 이동
// 즉] 중간에 변화가 있으면 뒤의 요소들의 위치변화가 일어남. (10만개면 99998개 데이터가 움직여야함)
// 링크구조 : [ 5 ] -> [ 4 ] -> [ 7 ] -> [ 10 ]
// 5/4주소값 -> 4/7주소값 -> 7/10주소값 -> 10/주소값없다
// 만약 1번 인덱스가 삭제되면 0번 인덱스 꼬리(4주소값을 -> 7주소값)변경
// 즉] 중간에 변화가 있으면 변화된 요소와 앞 요소의 연결(꼬리) 주소값만 변경하면 됨.
LinkedList< Integer > linkedList = new LinkedList<>();
// 다형성에 따라, List는 ArrayList, Vector, LinkedList와 부모-자식 관계로 접근 가능
List< Integer > integerList;
integerList = arrayList;
integerList = vector;
integerList = linkedList;
// vector = arrayList; 자식 대 자식은 안 됨
} // main end
} // class end
package day23; // package name
import java.util.*;
public class Example2 {
public static void main(String[] args) {
/*
[ 컬렉션 프레임워크2 ]
List 인터페이스 : 배열/링크구조 , 인덱스 있다. 중복 허용 한다(인덱스가 식별자)
Set 인터페이스 : 집합구조 , 인덱스 없다. 중복 허용하지 않는다(자료가 식별자) + 중복없는 집합
*/
// [1] HashSet 객체 생성
Set< String > set1 = new HashSet<>();
// [2] 주요 메소드
// 1) .add( 자료 ) : 집합 내 지정한 자료를 추가한다. 인덱스(순서) 없음
set1.add("유재석"); set1.add("강호동");
set1.add("신동엽"); set1.add("유재석"); // 이미 존재하는 자료는 중복이므로 불가능
System.out.println(set1); // [유재석, 강호동, 신동엽]
// 2) .size( ) : 집합 내 자료/요소 개수 반환
System.out.println(set1.size()); // 3
// *) .get( ) , .set( ) 메소드 없다. 인덱스 없어서
// 3) .contains( 자료 ) : 집합 내 자료가 존재하면 true , 없으면 false 반환
System.out.println(set1.contains("강호동")); // 강호동 있어서 true
// 4) .remove( 자료 ) : 집합 내 자료가 존재하면 삭제 없으면 삭제 안함.
set1.remove( "강호동" );
System.out.println( set1 ); // [유재석, 신동엽]
// 5) .isEmpty( ) : 집합 내 자료가 없으면 true, 한개 이상이면 false
System.out.println( set1.isEmpty() ); // false
// 6) .clear( ) : 집합 내 모든 자료/요소 삭제
// set1.clear( );
// [3] 집합과 반복문 관계
// 1) 일반for문 표현X : 인덱스가 없음
// 2) 향상된 for문 : for( 타입 반복변수명 : 리스트/집합명 ){ }
for( String str : set1 ){
System.out.println(str);
}
// 3) forEach문 : 리스트/집합명.forEach( (반복변수명) -> { 실행문 } );
set1.forEach( (str) -> {
System.out.println(str);
});
// [4] 구현체
// Set 인터페이스 : 순서 보장 없이 요소들을 저장하는 구조
// 1) HashSet : 중복없는 여러개 요소 저장 + 빠르다.
HashSet<Integer> hashSet = new HashSet<>();
// 2) TreeSet : 중복없는 여러개 요소 저장 + 저장된 자료들을 자동정렬(오름차순)
TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(30); treeSet.add(10); treeSet.add(20);
System.out.println(treeSet);
// 3) LinkedHashSet : 중복없는 여러개 요소 저장 + 링크구조 + 순서(인덱스없는) 보장 + 느리다.
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
Set<Integer> set2;
set2 = hashSet;
set2 = treeSet;
set2 = linkedHashSet;
// [활용] JDBC : ResultSet
} // main method end
} // class end
package day23; // package name
import java.util.*;
public class Example3 {
public static void main(String[] args) {
/*
[ 컬렉션 프레임워크3 ]
List 인터페이스 : 순서(인덱스)대로 저장하는 구조
Set 인터페이스 : 순서(인덱스)없이 저장하는 구조
Map 인터페이스 : keyt와 value를 한 쌍(entry)으로 여러 쌍을 저장하는 구조
-> HTML/CSS/JS <-> JAVA <-> DB
-> JSON : 자바스크립트에서 사용하는 객체 형식
-> JAVA에는 JSON이 없음. 비슷한 형식이 map
*/
// [1] HashMap 객체 생성 < key타입 , value타입 >
Map< String , Integer > map = new HashMap<>();
// [2] 주요 메소드
// 1) .put( key자료1 , value자료2 ) : Map 객체내 key와 value 자료를 한 쌍(entry)으로 저장한다.
map.put( "유재석" , 95 ); // "유재석" 자료는 key , 95 자료는 value
map.put( "강호동" , 100 ); // "강호동" 속성(key)명에 100 대입/저장한다.
map.put( "신동엽" , 78 );
map.put( "유재석" , 67 ); // key(속성명) 중복이 불가능하다. ( *식별자* )
map.put( "서장훈" , 100 ); // value(속성값) 중복이 가능하다.
System.out.println(map); // {서장훈=100, 유재석=67, 강호동=100, 신동엽=78}
// 2) .get( key ) : Map 객체내 지정한 key의 value 반환
System.out.println( map.get("유재석")); // 67
// 3) .size( ) : Map 객체내 entry(쌍) 개수 반환
System.out.println( map.size() ); // 엔트리 : 4 , key : 4 , value : 4 (자료 8개)
// 4) .remove( key ) : Map 객체내 지정한 key의 entry(쌍) 삭제한다.
map.remove("유재석");
System.out.println(map); // {서장훈=100, 강호동=100, 신동엽=78}, key를 삭제하면 value도 같이 삭제
// 5) .containsKey( key ) , .containsValue( value )
System.out.println(map.containsKey("강호동")); // "강호동" key가 있으므로 true
System.out.println(map.containsValue(65)); // 65 value가 없으므로 false
// 6) .clear( ) : Map 객체내 모든 entry 삭제한다.
// map.clear();
// System.out.println(map); // {}
// 7) .isEmpty( ) : Map 객체내 entry 하나도 없으면 true , 있으면 false
System.out.println(map.isEmpty()); // entry가 있으므로 false
// + .entrySet( ) : Map 객체내 모든 entry를 set 인터페이스 반환
System.out.println(map.entrySet()); // [서장훈=100, 강호동=100, 신동엽=78] 중괄호에서 대괄호로 반환
// + .keySet( ) : Map 객체내 모든 key를 set 인터페이스 반환
System.out.println(map.keySet()); // [서장훈, 강호동, 신동엽]
// + .values( ) : Map 객체내 모든 value를 List 인터페이스 반환
System.out.println(map.values()); // [100, 100, 78]
// 비정형화 vs 정형화(DB)
// [3] Map과 반복문 관계
// 1) 일반 for문 표현 못함 (인덱스 없음)
// 2) 향상된 for문 :
for( String key : map.keySet() ){ // map 객체내 모든 키를 반복한다.
System.out.println(key); // key * value 활용하여 key 호출한다 [x]
System.out.println(map.get(key)); // value * key 활용하여 value 호출한다 [o]
}
// 3) forEach문
map.keySet().forEach( (key) -> {
System.out.println(key);
System.out.println(map.get(key));
});
// 활용] JSON( JavaScript 객체 ) <---> MAP/DTO ( JAVA 객체 )
// DTO는 다회성 객체 , MAP은 일회성 객체
// [4] 구현체
// Map 인터페이스 : key와 value를 (자료 2개) 한 쌍(entry 자료 1개)으로 여러 쌍을 저장한다.
// 1) HashMap : key와 value로 구성된 entry 객체를 저장하는 구조
HashMap< Integer , Object > hashMap = new HashMap<>();
// 2) HashTable : + 동기화 메소드 제공 ( 멀티 스레드 플랫폼 )
Hashtable< Integer , Object > hashtable = new Hashtable<>();
// 3) TreeMap : + key값 기준으로 자동 정렬(오름차순)
TreeMap< Integer, Object > treeMap = new TreeMap<>();
// 4) Properties : + 제네릭이 없다. + 주로 세팅/설정 파일 사용된다. Spring 환경
Properties properties = new Properties();
Map< Integer , Object > map2;
map2 = hashMap;
map2 = hashtable;
map2 = treeMap;
} // main method end
} // class end
반응형