[자바(Java)] Map

//Map

- Collection 프레임워크의 일부

- Collection 인터페이스 구현 xx

1. HashMap

2. HashTable

3. LinkedHashMap

4. TreeMap

---

// HashMap

- 데이터를 키와 값의 쌍으로 저장.
└ 키(key):  컬렉션 내의 키(key) 중에서 유일해야 한다.
└ 값(value): 키(key)와 달리 데이터의 중복을 허용한다.

- 순서x / 순서를 유지하려면 LinkedHashMap 클래스를 사용하면 된다.

- 해싱(hashing) 기법으로 데이터를 저장하여 데이터가 많아도 검색이 빠르다.
└ 해싱: 해시함수(hash function)로 해시 테이블(hash table)에 데이터를 저장하고, 해시테이블에서 데이터를 검색.
└└ 해시 테이블: 배열과 LinkedList가 조합된 형태

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

- 선언 및 생성

HashMap<타입1, 타입2> hashMap명 = new HashMap<타입1, 타입2>();

- 값 추가 // key가 같은 경우 나중에 들어오는 값으로 덮어쓰기 된다.

hashMap명.put(key, value);

- 키와 값 불러오기

for(Entry<String, Integer> elem : hashMap.entrySet()){
            System.out.println(elem.getKey() + elem.getValue());
}

- 값 삭제

hashMap명.remove(key);

- 값 변경

hashMap명.replace(key, value);

- 값 불러오기

hashMap명.get(key);


- 키나 값이 있는지 확인 // true | false

hashMap명.containsKey(key);
hashMap명.containsValue(value);

- 길이 반환

hashMap명.size();

- map이 비었는지 확인 // true | false

hashMap명.isEmpty();

- map 모두 삭제

hashMap명.clear();

- map 복제

hashMap명.clone();

- 키와 값을 Set에 저장

hashMap명.entrySet();

- 키를 Set에 저장

hashMap명.keySet();


- 값을 컬렉션의 형태로 반환

hashMap명.values();

---

import java.util.HashMap;
import java.util.Map.Entry;
 
public class Ex01 {
	public static void main(String[] args) {
		HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
		
		hashMap.put("b", 20);
		hashMap.put("a", 20);
		hashMap.put("c", 30);
		hashMap.put("d", 10);
		
		System.out.println(hashMap);
		
		for(Entry<String, Integer> elem : hashMap.entrySet()){
            System.out.println("키: " + elem.getKey() + " / "+ "값: " + elem.getValue());
        }
	}
}

---

import java.util.HashMap;

public class Ex14 {
	public static void main(String[] args) {
		HashMap map = new HashMap();
		map.put(1, "B");
		map.put(2, "A");
		map.put(3, "G");
		map.put(4, "E");
		map.put(5, "F");
		System.out.println("map = " + map + "\n");
		
		System.out.println("3번에 해당하는 값 = " + map.get(3));
		System.out.println("map의 size = " + map.size() + "\n");
		
		map.remove(5);
		System.out.println("5번에 해당하는 값 삭제 후 = " + map);
		System.out.println("3번 키 존재 여부 확인 = " + map.containsKey(3));
		System.out.println("G라는 값 존재 여부 확인 = " + map.containsValue("G"));
		System.out.println("map의 size = " + map.size() + "\n");
		
		map.replace(3, "F");
		System.out.println("3번에 해당하는 값을 F로 변경 = " + map);
		System.out.println("3번 키 존재 여부 확인 = " + map.containsKey(3));
		System.out.println("G라는 값 존재 여부 확인 = " + map.containsValue("G"));
		System.out.println("map이 비었는지 확인 = " + map.isEmpty() + "\n");
		
		map.clear();
		System.out.println("map clear 후 = " + map);
		System.out.println("map이 비었는지 확인 = " + map.isEmpty() + "\n");
	}
}

---

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

public class Ex15 {
	public static void main(String[] args) {
		HashMap map = new HashMap();
		map.put("김자바", 90);
		map.put("김자바", 100);
		map.put("이자바", 80);
		map.put("손자바", 100);
		map.put("한자바", 90);
		
		System.out.println("map = " + map + "\n");
		
		Set set = map.entrySet();
		Iterator it = set.iterator();
		System.out.println("map의 entry를 set에 저장 = " + set);
		while(it.hasNext()) {
			Map.Entry e = (Map.Entry)it.next();
			System.out.println("이름 : " + e.getKey() + "," + "점수 : " + e.getValue());
		}
		System.out.println();
				
		Set set2 = map.keySet();
		System.out.println("map의 key를 set에 저장 (참가자 명단) = " + set2 + "\n");
		
		Collection values = map.values();
		System.out.println("map의 values를 Collection에 저장 (참가자 점수)= " + values);
		
		it = values.iterator();
		
		int total = 0;
		
		while(it.hasNext()) {
			int i = (int)it.next();
			total += i;
		}
		
		System.out.println("총점 : " + total);
		System.out.println("평균 : " + (double)total/set.size());
		System.out.println("최고 점수 : " + Collections.max(values));
		System.out.println("최저 점수 : " + Collections.min(values));
	}
}

 

---

// hashMap 정렬

* value 기준으로 내림차순 정렬
* 만약 value가 같을 경우 key 기준으로 오름차순 정렬

- import java.util.Collections;
- import java.util.Comparator;
- import java.util.Iterator;
- import java.util.LinkedHashMap;
- import java.util.LinkedList;
- import java.util.Map;

- 추가 import만 이만큼이다. 너무 많아서 import java.util.* 을 사용했다.

import java.util.*;
 
public class Ex01 {
	public static void main(String[] args) {
		HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
		
		hashMap.put("b", 20);
		hashMap.put("a", 20);
		hashMap.put("c", 30);
		hashMap.put("d", 10);	
		System.out.println("정렬 전: "+hashMap);    
		
		List<Map.Entry<String, Integer>> list = new LinkedList<>(hashMap.entrySet()); 
		Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
			@Override 
			public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
				if (o1.getValue() > o2.getValue()) {
					return -1; } 
				else if (o1.getValue() < o2.getValue()) {
						return 1; } 
				return o1.getKey().compareTo(o2.getKey());
	            }
	        });   
		Map<String, Integer> sortedMap = new LinkedHashMap<>();
		for(Iterator<Map.Entry<String, Integer>> iter = list.iterator(); iter.hasNext();){
			Map.Entry<String, Integer> entry = iter.next();
			sortedMap.put(entry.getKey(), entry.getValue());
		}
	    System.out.println("정렬 후: "+sortedMap);    
	}
}

---

//HashTable

- 모든 메서드가 Synchronized > HashMap보다 스레드가 더 안전하고, 분류되어 있지도, 순서가 있지도 않다.

- HashMap은 열쇠를 null 값과 저장할 수 있게 해주지만 HashTable은 불가능하다.

---

//LinkedHashMap

- 삽입 순서가 유지된다. 하지만 정렬되지 않았고 삽입 순서이기 때문에 HashMap보다 삽입과 제거 속도가 느리다.

- 요소간에 연결이 되어 있어 요소를 도는 iteration은 HashMap보다 훨씬 빠르다.

---

package collections;

import java.util.LinkedHashMap;

public class Map {

	public static void main(String[] args) {

		LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();

		linkedHashMap.put("F", 25);
		linkedHashMap.put("A", 15);
		linkedHashMap.put("Z", 5);
		linkedHashMap.put("L", 250);

		System.out.println(linkedHashMap);

	} //main

}

---

//TreeMap

- 기반 데이터 구조 > 정렬된 순서로 저장됨. > 다른 인터페이스도 구현 > NavigableMap

- 특정 값 바로 다음으로 큰 값 검색

treeMap명.higherKey(value);


- 특정 값과 같거나 바로 다음으로 큰 값 검색

treeMap명.ceilingKey(value);

- 특정 값 바로 다음으로 작은 값 검색

treeMap명.lowerKey(value);


- 특정 값과 같거나 바로 다음으로 작은 값 검색

treeMap명.floorKey(value);

- 첫 번째 '키+값 '검색

treeMap명.firstEntry();

- 마지막 '키+값'검색

treeMap명.lastEntry();

- 맨 앞부터 toKey 이전까지 추출하여 반환

SortedMap<k,v> headMap(K toKey)</k,v>;


- fromKey부터 끝까지 추출하여 반환

 SortedMap<k,v> tailMap(K fromKey)</k,v>;

- 시작 키와 마지막 키 사이에 있는 모든 '키+값' 검색

treeMap명.subMap(시작 키, 마지막 키); //마지막 키 포함x
    ~ treeMap명.subMap(시작 키, true, 마지막 키, true) //마지막 키 포함o

---

package collections;

import java.util.TreeMap;

public class Map {

	public static void main(String[] args) {

		TreeMap<String, Integer> treemap = new TreeMap<>();

		treemap.put("F", 25);
		treemap.put("A", 15);
		treemap.put("Z", 5);
		treemap.put("L", 250);

		System.out.println(treemap);

	} //main

}

---

package collections;

import java.util.TreeMap;

public class Map {

	public static void main(String[] args) {

		TreeMap<String, Integer> treemap = new TreeMap<>();

		treemap.put("F", 25);
		treemap.put("Z", 5);
		treemap.put("L", 250);
		treemap.put("A", 15);
		treemap.put("B", 25);
		treemap.put("G", 25);

		System.out.println(treemap);

		System.out.println(treemap.higherKey("B"));
		System.out.println(treemap.ceilingKey("B"));
		System.out.println(treemap.lowerKey("B"));
		System.out.println(treemap.floorKey("B"));
		System.out.println();

		System.out.println(treemap.firstEntry());
		System.out.println(treemap.lastEntry());
		System.out.println();

		System.out.println(treemap.subMap("F", "Z"));
		System.out.println(treemap.subMap("F", true, "Z", true));


	} //main

}

---

package com.test.collection;

import java.util.TreeMap;

public class Ex86_TreeMap {

	public static void main(String[] args) {

		TreeMap<String, String> map = new TreeMap<String, String>();
		
		map.put("white", "하양");
		map.put("black", "검정");
		map.put("yellow", "노랑");
		map.put("orange", "주황");
		map.put("green", "초록");
		map.put("red", "빨강");
		map.put("blue", "파랑");

		
		System.out.println(map); //key 자동 정렬
		System.out.println();
		
		System.out.println(map.firstKey());
		System.out.println(map.lastKey());
		System.out.println();
		
		System.out.println(map.get(map.firstKey()));
		System.out.println(map.firstEntry().getKey());
		System.out.println(map.firstEntry().getValue()); //권장
		System.out.println();
		
		System.out.println(map.headMap("m"));
		System.out.println(map.tailMap("m"));
		System.out.println(map.subMap("m", "t"));
		
	} //main
	
}