Java TreeMap

이 튜토리얼에서는 예제를 통해 Java TreeMap 클래스와 그 操作을 배웁니다.

그것은 상속받았습니다NavigableMap 인터페이스。

TreeMap 생성

TreeMap을 생성하기 위해 먼저 java.util.TreeMap 패키지를 가져오아야 합니다. 패키지를 가져온 후 다음과 같은 방법으로 Java에서 TreeMap을 생성할 수 있습니다.

TreeMap<Key, Value> numbers = new TreeMap<>();

위의 코드에서는 이름이 numbers인 TreeMap을 생성했지만 매개변수가 없습니다. 이 예제에서 TreeMap의 요소는 자연수 순으로 정렬됩니다.

하지만, Comparator 인터페이스를 사용하여 요소의 정렬을自定义할 수 있습니다. 이를 본 튜토리얼의 후반부에서 배울 것입니다.

여기서는

• Key - 맵의 각 요소(값)에 대한 독특한 식별자로 사용

• Value - 키와 연결된 맵의 요소

TreeMap 메서드

TreeMap 클래스는 맵에 대한 다양한 작업을 수행할 수 있는 방법을 제공합니다.

요소를 TreeMap에 삽입

• put() - 지정된 키/값 맵(항목)이 맵에 삽입됨

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

• putIfAbsent() - 지정된 키가 맵에 없으면 지정된 키/값 맵이 맵에 삽입됨

예를 들어

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

출력 결과

짝수의 TreeMap: {Four=4, Six=6,　Two=2}
TreeMap의 숫자: {Four=4, One=1, Six=6,　Two=2}

TreeMap 요소에 접근

1.entrySet(), keySet(), values() 사용

• entrySet() - TreeMap의 모든 키를 반환/값 맵(항목)의 집합

• keySet() - TreeMap의 모든 키의 집합을 반환

• values() - TreeMap의 모든 키의 집합을 반환

예를 들어

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

출력 결과

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

2. get()과 getOrDefault() 사용

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

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

예를 들어

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

출력 결과

TreeMap:　{One=1,　Three=3,　Two=2}
get() 사용:　3
getOrDefault() 사용:　5

TeeMap 요소를 제거합니다

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

• remove(key, value) -지정된 키와 지정된 값이 맵에 연결되어 있을 때만 맵에서 항목을 제거하고布尔값을 반환합니다

예를 들어

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

출력 결과

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

TreeMap 요소를 대체합니다

• replace(key, value)-key의 새로운 값을 사용하여 지정된 매핑의 값 value를 대체합니다

• replace(key, old, new) -이전 값이 지정된 키와 연결되어 있으면서야 새 값으로 대체됩니다

• replaceAll(function) -지정된 결과로 맵의 각 값을 대체하는 함수 function

예를 들어

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("원래 TreeMap: "　+　numbers);
　　　　　　　　//　replace() 사용
　　　　　　　　numbers.replace("Second",　22);
　　　　　　　　numbers.replace("Third",　3,　33);
　　　　　　　　System.out.println("TreeMap이 replace() 메서드를 사용하면: "　+　numbers);
　　　　　　　　//　replaceAll() 사용
　　　　　　　　numbers.replaceAll((key, oldValue)　-> oldValue　+　2);
　　　　　　　　System.out.println("TreeMap이 replaceAll() 메서드를 사용하면: "　+　numbers);
　　　　}
}

출력 결과

원래 TreeMap: {First=1,　Second=2, Third=3}
TreeMap이 replace() 메서드를 사용하면: {First=1,　Second=22, Third=33}
TreeMap이 replaceAll() 메서드를 사용하면: {First=3,　Second=24, Third=35}

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

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

여기서, 우리는 다음을 전달했습니다.라미다 표현식파라미터로 사용.

replaceAll() 메서드는 맵의 모든 항목에 접근합니다. 그런 다음, 모든 요소를 새 값으로 대체합니다(라미다 표현식에서 반환됨).

탐색 메서드

TreeMap 클래스가 NavigableMap를 구현했기 때문에 TreeMap 요소에서의 탐색을 위한 다양한 메서드를 제공합니다.

1. 첫 번째와 마지막 메서드

• firstKey() - 맵의 첫 번째 키를 반환

• firstEntry() - 맵의 첫 번째 키의 키를 반환/값 매핑

• lastKey() - 맵의 마지막 키를 반환

• lastEntry() - 마지막 키의 키를 반환/값 매핑

예를 들어

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//　the firstKey() 메서드 사용
　　　　　　　　String firstKey = numbers.firstKey();
　　　　　　　　System.out.println("첫 번째 키: " );　+　firstKey);
　　　　　　　　//　the lastKey() 메서드 사용
　　　　　　　　String lastKey = numbers.lastKey();
　　　　　　　　System.out.println("마지막 키: " );　+　lastKey);
　　　　　　　　//　firstEntry() 메서드 사용
　　　　　　　　System.out.println("첫 번째 항목: " );　+　numbers.firstEntry());
　　　　　　　　//　사용자 the lastEntry() 메서드
　　　　　　　　System.out.println("마지막 항목: ");　+　numbers.lastEntry());
　　　　}
}

출력 결과

TreeMap: {First=1,　Second=2, Third=3}
첫 번째 키: First
마지막 키: Third
첫 번째 항목: First=1
마지막 항목: Third=3

2.위로, 아래로, 상하한 제한 메서드

• HigherKey() - 지정된 키보다 큰 키와 관련된 가장 작은 키를 반환합니다.

• HigherEntry() - 지정된 키보다 큰 모든 키와 관련된 가장 작은 키의 엔트리를 반환합니다.

• lowerKey() - 지정된 키보다 작은 모든 키의 가장 큰 키를 반환합니다.

• lowerEntry() - 지정된 키보다 작은 모든 키와 관련된 가장 큰 키의 엔트리를 반환합니다.

• ceilingKey() - 지정된 키보다 큰 키와 관련된 가장 작은 키를 반환합니다. 매핑에 전달된 키가 존재하면, 그 키를 반환합니다.

• ceilingEntry() - 지정된 키보다 큰 키와 관련된 가장 작은 키의 엔트리를 반환합니다. 매핑에 전달된 키와 관련된 엔트리가 존재하면, 그 엔트리를 반환합니다.

• floorKey() - 지정된 키보다 작은 키와 관련된 가장 큰 키를 반환합니다. 매개변수로 키가 전달되면, 그 키를 반환합니다.

• floorEntry() - 지정된 키보다 작은 키와 관련된 가장 큰 키의 엔트리를 반환합니다. 매개변수로 키가 전달되면, 그 키를 반환합니다.

예를 들어

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　5);
　　　　　　　　numbers.put("Third",　4);
　　　　　　　　numbers.put("Fourth",　6);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//　사용자 higher()
　　　　　　　　System.out.println("사용자 higherKey(): ");　+　numbers.higherKey("Fourth"));
　　　　　　　　System.out.println("사용자 higherEntry(): ");　+　numbers.higherEntry("Fourth"));
　　　　　　　　//　사용자 lower()
　　　　　　　　System.out.println("\n사용자 lowerKey(): ");　+　numbers.lowerKey("Fourth"));
　　　　　　　　System.out.println("사용자 lowerEntry(): ");　+　numbers.lowerEntry("Fourth"));
　　　　　　　　//　사용자 ceiling()
　　　　　　　　System.out.println("\n사용자 key(): ");　+　numbers.ceilingKey("Fourth"));
　　　　　　　　System.out.println("사용자 entry(): ");　+　numbers.ceilingEntry("Fourth"));
　　　　　　　　//　floor() 사용
　　　　　　　　System.out.println("\nfloorKey() 사용:\　+　numbers.floorKey("Fourth"));
　　　　　　　　System.out.println("floorEntry() 사용:\　+　numbers.floorEntry("Fourth"));
　　　　}
}

출력 결과

TreeMap: {First=1,　Fourth=6,　Second=5, Third=4}
higherKey(): Second
higherEntry(): Second=5
lowerKey(): First
lowerEntry(): First=1
ceilingKey(): Fourth
ceilingEntry(): Fourth=6
floorkey(): Fourth
floorEntry(): Fourth=6

3. pollFirstEntry()와 pollLastEntry() 메서드

• pollFirstEntry() - 지정된 맵의 첫 번째 키와 연관된 항목을 반환하고 삭제합니다

• pollLastEntry()　 -지정된 맵의 마지막 키와 연관된 항목을 반환하고 삭제합니다

예를 들어

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//pollFirstEntry() 메서드 사용
　　　　　　　　System.out.println("pollFirstEntry() 사용:\　+　numbers.pollFirstEntry());
　　　　　　　　//　pollLastEntry() 메서드 사용
　　　　　　　　System.out.println("pollLastEntry() 사용:\　+　numbers.pollLastEntry());
　　　　　　　　System.out.println("업데이트된 TreeMap: ");　+　numbers);
　　　　}
}

출력 결과

TreeMap: {First=1,　Second=2, Third=3}
pollFirstEntry(): First=1
pollLastEntry(): Third=3
업데이트된 TreeMap: {Second=2}

4. headMap(), tailMap() 및 subMap() 메서드

headMap(key,booleanValue)

booleanValue 매개변수는 선택 사항입니다. 기본 값은 false입니다.

booleanValue가 true라면, 이 메서드는 지정된 키의 키도 포함합니다/값 쌍.

예를 들어

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　System.out.println("\n사용자 headMap() 메서드:\
　　　　　　　　//　headMap()을 기본 booleanValue로 사용 false
　　　　　　　　System.out.println("부울 값을 지정하지 않았을 때:　"　+　numbers.headMap("Fourth"));
　　　　　　　　//　headMap()은 지정된 booleanValue를 true로 사용
　　　　　　　　System.out.println("지정된 부울 값을 true로 설정:　"　+　numbers.headMap("Fourth", true));
　　　　}
}

출력 결과

TreeMap: {First=1,　Fourth=4,　Second=2, Third=3}
headMap() 메서드를 사용:　
부울 값을 지정하지 않았을 때:　{First=1}
지정된 부울 값을 true로 설정:　{First=1,　Fourth=4}

tailMap(key,booleanValue)

tailMap() 메서드는 지정된 키(파라미터로 전달됨)에서 시작하여 트리맵의 모든 키를 반환합니다./값 쌍.

booleanValue는 선택적 파라미터입니다. 기본 값은 true입니다.

booleanValue가 false라면, 이 메서드는 지정된 키의 키를 포함하지 않습니다./값 쌍.

예를 들어

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　System.out.println("\ntailMap() 메서드를 사용:\
　　　　　　　　//　tailMap() booleanValue를 기본 값 true
　　　　　　　　System.out.println("booleanValue를 기본 true로 사용:　"　+　numbers.tailMap("Second"));
　　　　　　　　//　tailMap() booleanValue를 지정한 false
　　　　　　　　System.out.println("booleanValue를 지정한 false:　"　+　numbers.tailMap("Second", false));
　　　　}
}

출력 결과

TreeMap: {First=1,　Fourth=4,　Second=2, Third=3}
tailMap() 메서드를 사용:
booleanValue를 기본 true로 사용:　{Second=2, Third=3}
booleanValue를 지정한 false:　{Third=3}

subMap(k1,bV1,k2,bV2)

subMap() 메서드는 k1과 k2간의 키와 연결된 모든 항목,包括k1의 항목.

bV1과 bV2은 선택적 부울 파라미터입니다. 　bV1의 기본 값은 true이며, bV2의 기본 값은 false입니다.

bV1이 false라면, 이 메서드는 k1과 k2간의 키와 연결된 모든 항목,但不包括k1의 항목.

bV2이 true라면, 이 메서드는 k1과 k2간의 키와 연결된 모든 항목,包括k2의 항목.

예를 들어

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　System.out.println("\n使用 subMap() 方法:");
　　　　　　　　//　tailMap() 使用默认布尔值
　　　　　　　　System.out.println("使用默认布尔值: "　+　numbers.subMap("Fourth", "Third"));
　　　　　　　　//　tailMap() 指定布尔值
　　　　　　　　System.out.println("指定布尔值: "　+　numbers.subMap("Fourth", false, "Third", true));
　　　　}
}

출력 결과

TreeMap: {First=1,　Fourth=2,　Second=2, Third=3}
使用 subMap() 方法:
使用默认布尔值: {Fourth=4,　Second=2}
指定布尔值: {Second=2, Third=3}

TreeMap的其他方法

TreeMap 比较器

在以上所有示例中，treemap元素都自然排序（以升序排列）。但是，我们也可以自定义键的顺序。

为此，我们需要基于对树图中的键进行排序的方式来创建自己的比较器类。例如，

import java.util.TreeMap;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//使用自定义比较器创建treemap
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>(new CustomComparator());
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　}
　　　　//创建一个比较器类
　　　　public static class CustomComparator implements Comparator<String> {
　　　　　　　　@Override
　　　　　　　　public　int　compare(String　number1,　String　number2)　{
　　　　　　　　　　　　int　value　=　　number1.compareTo(number2);
　　　　　　　　　　　　//요소는 반대 순서로 정렬됩니다
　　　　　　　　　　　　if　(value　>　0)　{
　　　　　　　　　　　　　　　　return　-1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else　if　(value　<　0)　{
　　　　　　　　　　　　　　　　return　1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else　{
　　　　　　　　　　　　　　　　return　0;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

출력 결과

TreeMap:　{Third=3,　Second=2,　Fourth=4,　First=1}

위의 예제에서는 CustomComparator 클래스를 매개변수로 전달하여 TreeMap을 생성했습니다.

CustomComparator 클래스는 Comparator 인터페이스를 구현합니다.

그런 다음 compare() 메서드를 반대 순서로 요소를 정렬하는 방식으로 재정의합니다.