- Map : Key, Value 형태로 데이터를 저장하는 자료구조
- HashMap : Map 인터페이스를 구현한 Map 컬렉션 (순서보장X)
- LinkedHashMap : Map 인터페이스를 구현한 Map 컬렉션 (순서보장O)
Map 선언
Map<String, Object> map = new HashMap<String, Object>();
Map value의 자료형이 Object이기 때문에 모든 Object가 다 들어갈 수 있다.
Map<> map = new HashMap<>() 를 사용하는 이유 :
HashMap을 선언 시, Map<String, Object> map = new HashMap<String, Object>(); 과 같은 형식으로 선언한 것을 쉽게 찾아볼 수 있다.
1. 인터페이스니까
▶ 포폴 개발을 진행할 때, List list = new List();와 같이 선언할 수 없었다.
그 이유는 List는 Interface라서 바디를 직접 작성할 수 없기 때문이었다.
Map도 같은 이유이다.
① Map은 인터페이스다.
② 따라서 Body를 직접 작성할 수 없다.
③ HashMap은 Map 인터페이스를 구현했다.
2. 코드의 유연성을 높일 수 있으니까
▶ Map을 구현한 객체는 HashMap, TreeMap 등이 있다.
Map으로 선언할 경우, HashMap으로 선언할 때보다 가짓수가 많아진다.
결국 코드의 유연성을 높일 수 있게 되는 것이다.
① Map map = new TreeMap<>();
② Map map = new HashMap<>();
Map 데이터 삽입
map.put("animal", "cat"); // {animal=cat}
map.put("food", "pizza"); // {animal=cat, food=pizza}
// 이미 "animal" 키값이 있기 때문에 "dog" 로 갱신되지 않음
map.putIfAbsent("animal", "dog"); // {animal=cat, food=pizza}
map.putIfAbsent("animal2", "dog"); // {animal=cat, animal2=dog, food=pizza}
Map<String, String> cities = new HashMap<>();
cities.put("Tokyo", "Japan");
cities.put("Seoul", "Korea");
cities.put("Beijing", "China");
cities.put("Paris", "France");
cities.put("Washington", "USA");
cities.put("Brazilia", "Brazil");
V put(K key, V value) 로 값을 넣을 수 있다.
put(k, v) 을 했을 때 이미 키값이 존재한다면 데이터를 덮어쓴다.
putIfAbsent 을 이용하면 Map 에 Key 값이 없을 때에만 데이터를 넣을 수 있다.
Map 데이터 출력
map.get("animal"); // "cat"
map.getOrDefault("food", "chicken"); // "pizza"
map.getOrDefault("food2", "chicken"); // "chicken"
// Normal ways
//1)
for (Map.Entry<String, String> entry : cities.entrySet()) {
System.out.println("Cities: " + entry.getKey() + ", " + entry.getValue());
}
//2)
for (String key : cities.keySet()) {
System.out.println("Cities: " + key + ", " + cities.get(key));
}
// Java8 forEach, Lambda
// 1)
cities.forEach((k, v) -> System.out.println("Cities: " + k + ", " + v));
// 2)
cities.forEach((k, v) -> {
System.out.println("Cities: " + k + ", " + v);
});
//출력결과
Cities: Beijing, China
Cities: Tokyo, Japan
Cities: Seoul, Korea
Cities: Brazilia, Brazil
Cities: Paris, France
Cities: Washington, USA
V get(Object key) 로 value 값을 가져올 수 있다.
V getOrDefault(Object key, V defaultValue) 을 사용하면 key 값이 없을 때 null 대신 설정된 값을 리턴한다.
Map 데이터 삭제
map.remove("animal2");
V remove(Object key) 로 데이터를 삭제 할 수 있다.
Map 데이터 확인
map.containsKey("food"); // true
map.containsValue("dog"); // false
boolean containsKey(Object key) 또는 boolean containsValue(Object value) 로 key 나 value 값이 존재하는 지 확인할 수 있다.
Map 크기(길이) 확인
map.size();
Key, Value 묶음 가져오기
// map: {animal=cat, food=pizza}
map.keySet(); // [animal, food]
map.values(); // [cat, pizza]
Set<K> keySet() 은 Key들로 이루어진 Set 자료구조를 리턴한다.
Collection<V> values() 은 Value 들로 이루어진 Collection 을 리턴한다.
Map 순회
// 출력
// animal: cat
// food: pizza
map.forEach((k, v) -> {
System.out.println(k + ": " + v);
});
// 한 줄이면 중괄호 { } 생략 가능
map.forEach((k, v) -> System.out.println(k + ": " + v));
// 람다식 안쓰고 for 문으로 구현. forEach 도 내부적으로는 이렇게 구현되어있음
for (Map.Entry entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
forEach 를 사용해서 Map 을 순회할 수 있다.
람다식을 이용하면 좀더 간단하게 나타낼 수 있으며 코드가 한줄이라면 중괄호 { } 를 생략할 수 있다.
Map Compute 데이터 치환
map.compute("animal", (k, v) -> {
System.out.println(k + "'s value is " + v + " -> lion"); // animal's value is cat -> lion
return "lion";
});
// map: {animal=lion, food=pizza}
map.computeIfAbsent("fruit", (k) -> {
System.out.println("New value of " + k + " is apple"); // New value of fruit is apple
return "apple";
});
// map: {fruit=apple, animal=lion, food=pizza}
map.computeIfPresent("animal", (k, v) -> {
System.out.println(k + "'s value is " + v + " -> tiger"); // animal's value is lion -> tiger
return "tiger";
});
// map: {fruit=apple, animal=tiger, food=pizza}
compute 를 사용해 원하는 로직을 실행하고 데이터를 넣을 수 있다.
만약 Key 가 없으면 새로운 데이터를 넣어주고 Key 값이 있으면 데이터를 갱신해준다.
만약 기존에 없는 데이터로 compute 연산을 하게 될 때 value 값은 null 이 된다.
computeIfAbsent 와 computeIfPresent 는 조건을 걸어서 compute 연산을 실행한다.
computeIfAbsent 는 Key 가 없을 때만 실행되기 때문에 람다식으로도 key 값 하나 밖에 받지 않는다.
computeIfPresent 는 Key 값이 존재할 때만 실행된다.
만약 Key 가 없거나 있어서 조건이 일치하지 않으면 로직이 아예 실행되지 않는다.
LinkedHashMap 순서 유지
Map<String, String> map = new LinkedHashMap<>();
map.put("animal", "cat");
map.put("fruit", "apple");
System.out.println(map); // {animal=cat, fruit=apple}
map.put("animal", "dog");
System.out.println(map); // {animal=dog, fruit=apple}
map.forEach((k, v) -> System.out.print(k + ": " + v + ", ")); // animal: dog, fruit: apple,
HashMap 은 hashcode 를 사용하기 때문에 순서가 일정하지 않다.
LinkedHashMap 은 내부를 Double-Linked List 로 구성하여 HashMap 의 순서를 유지한다.
HashMap 에서 상속받기 때문에 HashMap 의 모든 메소드를 사용할 수 있다.
데이터는 먼저 들어간 데이터가 무조건 앞에 위치하게 된다.
forEach 문에서도 동일하다.
추가 소스
package exam;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
public class exam3 {
public static void main(String[] args) {
Map<String, String> map = new LinkedHashMap<String, String>();
map.put("key01", "value01");
map.put("key02", "value02");
map.put("key03", "value03");
map.put("key04", "value04");
map.put("key05", "value05");
//entrySet() 메서드는 key와 value의 값 모두 출력
//keySet() 메서드는 key의 값만 출력
//Iterator는 자바의 컬렉션 프레임워크에서 컬렉션에 저장되어 있는 요소들을 읽어오는 방법
// 방법 01 : entrySet()
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("방법1: [key]:" + entry.getKey() + ", [value]:" + entry.getValue());
}
System.out.println("----------------------------------------------------------------------------------");
// 방법 02 : keySet()
for (String key : map.keySet()) {
String value = map.get(key);
System.out.println("방법2: [key]:" + key + ", [value]:" + value);
}
System.out.println("----------------------------------------------------------------------------------");
// 방법 03 : entrySet().iterator()
Iterator<Map.Entry<String, String>> iteratorE = map.entrySet().iterator();
while (iteratorE.hasNext()) {
Map.Entry<String, String> entry = (Map.Entry<String, String>) iteratorE.next();
String key = entry.getKey();
String value = entry.getValue();
System.out.println("방법3: [key]:" + key + ", [value]:" + value);
}
System.out.println("----------------------------------------------------------------------------------");
// 방법 04 : keySet().iterator()
Iterator<String> iteratorK = map.keySet().iterator();
while (iteratorK.hasNext()) {
String key = iteratorK.next();
String value = map.get(key);
System.out.println("방법4: [key]:" + key + ", [value]:" + value);
}
System.out.println("----------------------------------------------------------------------------------");
// 방법 05 : Lambda 사용
map.entrySet().stream().forEach(entry-> {
System.out.println("방법5: [key]:" + entry.getKey() + ", [value]:"+entry.getValue());
});
System.out.println("----------------------------------------------------------------------------------");
// 방법 06 : Stream 사용
map.entrySet().stream().forEach(entry-> {
System.out.println("방법6-1: [key]:" + entry.getKey() + ", [value]:"+entry.getValue());
});
System.out.println("----------------------------------------------------------------------------------");
// Stream 사용 - 내림차순
map.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEach(entry-> {
System.out.println("방법6-2: [key]:" + entry.getKey() + ", [value]:"+entry.getValue());
});
System.out.println("----------------------------------------------------------------------------------");
// Stream 사용 - 오름차순
map.entrySet().stream().sorted(Map.Entry.comparingByKey(Comparator.reverseOrder())).forEach(entry-> {
System.out.println("방법6-3: [key]:" + entry.getKey() + ", [value]:"+entry.getValue());
});
}
}
