Java HashMap

이 튜토리얼에서는 예제를 통해 Java HashMap 클래스와 그 메서드를 배웁니다.

Java 컬렉션 프레임워크의 HashMap 클래스는 제공합니다Map 인터페이스의 해시 테이블 구현

HashMap을 생성합니다

HashMap을 생성하려면 먼저 java.util.HashMap 패키지를 가져와야 합니다. 패키지를 가져온 후 Java로 해시 테이블을 사용할 수 있습니다.

//생성된8개의 용량과 0.6부하 요소의 HashMap
HashMap<Key, Value> numbers = new HashMap<>();8, 0.6f);

위의 코드에서는 numbers라는 이름의 HashMap을 생성했습니다.

여기서는

• Key -map에 있는 각 요소(값)을 연결하는 고유한 식별자

• Value -map에 연결된 요소

new HashMap<>()을 주의하세요}}8,0.6) 부분. 여기서, 첫 번째 파라미터는 capacity, 두 번째 파라미터는 loadFactor입니다.

• capacity - HashMap의 용량은8이는 저장할 수 있는8항목.

• loadFactor -　 hashmap의 부하 요소는 0입니다.6이는 해시 테이블이 가득 차면60%이면, 항목은 원래 해시 테이블의 두 배 크기인 새 해시 테이블로 이동됩니다.

기본 용량과 부하 요소

용량과 부하 요소를 정의하지 않고 해시 테이블을 생성하는 것은 허용됩니다. 예를 들어,

//기본 용량과 부하 요소를 가진 HashMap
HashMap<Key, Value> numbers1　= new HashMap<>();

기본적으로

• HashMap의 용량은 16

• 부하 요소는 0으로 설정됩니다.75

기타 map에서 HashMap을 생성

이는 다른 map의 모든 요소를 포함한 HashMap을 생성하는 방법입니다.

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//좌수 hashmap을 생성
　　　　　　　　HashMap<String, Integer> evenNumbers = new HashMap<>();
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　System.out.println("HashMap1: "　+　evenNumbers);
　　　　　　　　//기타 hashmap에서 hashmap을 생성
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>(evenNumbers);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap2: "　+　numbers);
　　　　}
}

출력 결과

HashMap1: {Four=4, Two=2}
HashMap2: {Two=2, Three=3,　Four=4}

HashMap의 메서드

이 HashMap 클래스는 map에서 다양한操作을 수행할 수 있는 방법을 제공합니다.

요소를 HashMap에 삽입

• put() - 지정된 키/값 매핑을 map에 삽입

• putAll() - 지정된 map의 모든 항목을 이 map에 삽입

• putIfAbsent() - map에 지정된 키가 없으면, 지정된 키/값 매핑을 map에 삽입

예를 들어,

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//좌수 HashMap을 생성
　　　　　　　　HashMap<String, Integer> evenNumbers = new HashMap<>();
　　　　　　　　//　사용할 put()
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　//　사용할 putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Six",　6);
　　　　　　　　System.out.println("좌수 HashMap: "　+　evenNumbers);
　　　　　　　　//numbers의 HashMap을 생성
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　//　사용할 putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("numbers의 HashMap:　"}　+　numbers);
　　　　}
}

출력 결과

짝수 HashMap:　{Six=6,　Four=4, Two=2}
numbers의 HashMap:　{Six=6,　One=1,　Four=4, Two=2}

HashMap 요소에 접근

1.entrySet()와 keySet()와 values()를 사용하여

• entrySet() -모든 키의 집합을 반환합니다/값 맵의 맵

• keySet() -모든 맵 키의 집합을 반환합니다

• values() -모든 맵 값의 집합을 반환합니다

예를 들어,

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//　entrySet()를 사용하여
　　　　　　　　Key/Value　맵:　"　+　numbers.entrySet());
　　　　　　　　//　keySet()를 사용하여
　　　　　　　　System.out.println("Keys:　"　+　numbers.keySet());
　　　　　　　　//　values()를 사용하여
　　　　　　　　System.out.println("Values:　"　+　numbers.values());
　　　　}
}

출력 결과

HashMap: {One=1, Two=2, Three=3}
Key/Value　맵:　[One=1, Two=2, Three=3]
Keys:　[One,　Two,　Three]
Values:　[1,　2,　3]

2.get()와 getOrDefault()를 사용하여

• get() - 지정된 키와 연관된 값을 반환합니다. 키를 찾지 못하면 null을 반환합니다.

• getOrDefault() - 지정된 키와 연관된 값을 반환합니다. 키를 찾지 못하면 지정된 기본 값을 반환합니다.

예를 들어,

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//　get()를 사용하여
　　　　　　　　int　value1　=　numbers.get("Three");
　　　　　　　　System.out.println("반환 숫자:　"　+　value1);
　　　　　　　　//　getOrDefault()를 사용하여
　　　　　　　　int　value2　=　numbers.getOrDefault("Five",　5);
　　　　　　　　System.out.println("반환 숫자:　"　+　value2);
　　　　}
}

출력 결과

HashMap: {One=1, Two=2, Three=3}
숫자를 반환합니다:　3
숫자를 반환합니다:　5

요소를 제거합니다

• remove(key)　 - 지정된 키와 연관된 항목을 반환하고 맵에서 제거합니다

• remove(key, value)　 - 지정된 키가 지정된 값에 매핑되어 브루넬르 값을 반환할 때만 맵에서 해당 항목을 제거합니다

예를 들어,

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//단일 매개변수 제거 메서드
　　　　　　　　int　value　=　numbers.remove("Two");
　　　　　　　　System.out.println("삭제 값:　"　+　value);
　　　　　　　　//가 두 개의 매개변수를 가진 제거 메서드
　　　　　　　　boolean　result　=　numbers.remove("Three",　3);
　　　　　　　　System.out.println("条目"3삭제되었습니까? "　+　result);
　　　　　　　　System.out.println("갱신된 HashMap: "　+　numbers);
　　　　}
}

출력 결과

HashMap: {One=1, Two=2, Three=3}
삭제된 값:　2
항목3삭제되었습니까? True
갱신된 HashMap: {One=1}

요소를 대체합니다

• replace(key, value) - 키의 값을 value로 대체합니다

• replace(key, old, new) - old 값이 지정된 키 key와 연결되어 있다면만, new 값으로 old 값을 대체합니다

• replaceAll(function) - 지정된 함수의 결과를 사용하여 매핑된 각 값을 대체합니다

예를 들어,

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("원래 HashMap: "　+　numbers);
　　　　　　　　//　replace() 사용
　　　　　　　　numbers.replace("Second",　22);
　　　　　　　　numbers.replace("Third",　3,　33);
　　　　　　　　System.out.println("replace() 사용하여 HashMap의 값을 변경: "　+　numbers);
　　　　　　　　//　replaceAll() 사용
　　　　　　　　numbers.replaceAll((key, oldValue)　->　oldValue　+　2);
　　　　　　　　System.out.println("replaceAll() 사용하여 HashMap의 값을 변경: "　+　numbers);
　　　　}
}

출력 결과

원래 HashMap: {Second=2, Third=3,　First=1}
replace() 사용하여 HashMap의 값을 변경: {Second=22, Third=33,　First=1}
replaceAll() 사용하여 HashMap의 값을 변경: {Second=24, Third=35,　First=3}

위 프로그램에서 주의해야 할 점은 다음과 같습니다

numbers.replaceAll((key, oldValue)　->　oldValue　+　2);

이 경우, 이 메서드는 map의 모든 항목에 접근합니다. 그런 다음 모든 값을람다 표현식제공된 새로운 값.

값을 다시 계산합니다

1.compute() 메서드 사용

• compute() - 지정된 함수를 사용하여 새로운 값을 계산합니다. 그런 다음 계산된 값을 지정된 키와 연결합니다.

• computeIfAbsent() - 지정된 키가 어떤 값에 매핑되어 있지 않으면, 이 메서드는 지정된 함수를 사용하여 새로운 값을 계산합니다. 그런 다음 새로운 값을 키와 연결합니다.

• computeIfPresent() -지정된 키가 이미 어떤 값에 매핑되어 있다면, 이 메서드는 지정된 함수를 사용하여 새로운 값을 계산합니다. 그런 다음 새로운 값을 키와 연결합니다.

예를 들어,

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　System.out.println("원래 HashMap：　"　+　numbers);
　　　　　　　　//　compute() 사용
　　　　　　　　numbers.compute("First", (key, oldValue)　->　oldValue　+　2);
　　　　　　　　numbers.compute("Second", (key, oldValue)　->　oldValue　+　1);
　　　　　　　　System.out.println("HashMap 사용 compute(): "　+　numbers);
　　　　　　　　//　computeIfAbsent()를 사용하여
　　　　　　　　numbers.computeIfAbsent("Three",　key　->　5);
　　　　　　　　System.out.println("HashMap을 computeIfAbsent()를 사용하여 "　+　numbers);
　　　　　　　　//　computeIfPresent()를 사용하여
　　　　　　　　numbers.computeIfPresent("Second",　(key,　oldValue)　->　oldValue　*　2);
　　　　　　　　System.out.println("HashMap을 computeIfPresent()를 사용하여 "　+　numbers);
　　　　}
}

출력 결과

원래 HashMap：　{Second=2,　First=1}
HashMap을 compute()를 사용하여 {Second=3,　First=3}
HashMap을 computeIfAbsent()를 사용하여 {Second=3　First=3, Three=5}
HashMap을 computeIfPresent()를 사용하여 {Second=6,　First=3,　three=5}

위의 예제에서 compute() 메서드를 사용하여 맵의 값을 다시 계산했습니다

여기서는람다 표현식메서드 매개변수로 값을 다시 계산합니다

2. merge() 메서드를 사용하여

만약 지정된 키가 아직 연결되지 않았다면, merge() 메서드는 지정된 값을 지정된 키와 연결합니다

만약 지정된 키가 이미 값과 연결되어 있다면, 새로운 지정된 값을 기존의 오래된 값과 결합합니다. 예를 들어

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　System.out.println("원래 HashMap：　"　+　numbers);
　　　　　　　　//　merge() 메서드를 사용하여
　　　　　　　　numbers.merge("First",　4,　(oldValue,　newValue)　->　oldValue　+　newValue);
　　　　　　　　System.out.println("새로운 HashMap：　"　+　numbers);
　　　　}
}

출력 결과

원래 HashMap：　{Second=2,　First=1}
새로운 HashMap：　{Second=2,　First=5}

위의 예제에서 merge() 메서드는3개의 매개변수：key，newValue그리고 람다 표현식（새로운 결합 값을 계산하는 데 사용됩니다）.

HashMap의 다른 메서드

HashMap을 순회합니다

HashMap에서는 다음과 같이

• 를 순회합니다 키

• 를 순회합니다 값

• 를 순회합니다 키/값

1.forEach 루프 사용

import java.util.HashMap;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//HashMap을 생성
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//키 접근/치(key/value 대
　　　　　　　　System.out.print("항목: ");
　　　　　　　　for(Entry<String, Integer> entry: numbers.entrySet()) {
　　　　　　　　　　　　System.out.print(entry);
　　　　　　　　　　　　System.out.print(",");
　　　　　　　　}
　　　　　　　　//접근 key
　　　　　　　　System.out.print("\n모든 키: ");
　　　　　　　　for(String key: numbers.keySet()) {
　　　　　　　　　　　　System.out.print(key);
　　　　　　　　　　　　System.out.print(",");
　　　　　　　　}
　　　　　　　　//value 접근
　　　　　　　　System.out.print("\n모든 값: ");
　　　　　　　　for(Integer value: numbers.values()) {
　　　　　　　　　　　　System.out.print(value);
　　　　　　　　　　　　System.out.print(",");
　　　　　　　　}
　　　　}
}

출력 결과

HashMap: {One=1, Two=2, Three=3}
모든 항목: One=1, Two=2, Three=3
모든 키: One, Two, Three,
모든 값:　1,　2, ,3,

위 프로그램에서는 java.util.Map.Entry 패키지를 가져왔음을 주의해 주세요. 여기서 Map.Entry는 Map 인터페이스의 내장 클래스입니다.

이 내장 클래스는 map의 뷰(요소)를 반환합니다.

2.iterator() 메서드 사용

iterator() 메서드를 사용하여 HashMap을迭代할 수도 있습니다. 이 메서드를 사용하려면 java.util.Iterator 패키지를 가져오아야 합니다.

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//HashMap을 생성합니다.
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//Iterator 객체를 생성합니다.
　　　　　　　　Iterator<Entry<String, Integer>> iterate1　= numbers.entrySet().iterator();
　　　　　　　　//　접근 Key/Value 대
　　　　　　　　System.out.print("모든 항목: ");
　　　　　　　　while(iterate1.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate1.next());
　　　　　　　　　　　　System.out.print(",");
　　　　　　　　}
　　　　　　　　//　접근 key
　　　　　　　　Iterator<String> iterate2　= numbers.keySet().iterator();
　　　　　　　　System.out.print("\n모든 키: ");
　　　　　　　　while(iterate2.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate2.next());
　　　　　　　　　　　　System.out.print(",");
　　　　　　　　}
　　　　　　　　//　value 접근
　　　　　　　　Iterator<Integer> iterate3　= numbers.values().iterator();
　　　　　　　　　System.out.print("\n모든 값: ");
　　　　　　　　while(iterate3.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate3.next());
　　　　　　　　　　　　System.out.print(",");
　　　　　　　　}
　　　　}
}

출력 결과

HashMap: {One=1, Two=2, Three=3}
모든 항목: One=1, Two=2, Three=3
모든 키: One, Two, Three,
모든 값:　1,　2,　3,

위의 프로그램에서는 java.util.Map.Entry 패키지를 이미 가져왔습니다. 여기서 Map.Entry는 Map 인터페이스의 내장 클래스입니다.

이 내장 클래스는 map의 뷰(요소)를 반환합니다.