Java TreeMap

In diesem Tutorial werden wir durch Beispiele lernen, wie man die Java TreeMap-Klasse und ihre Operationen verwendet.

Es erbt vonNavigableMap-Schnittstelle.

Eine TreeMap erstellen

Um eine TreeMap zu erstellen, müssen wir zunächst das Paket java.util.TreeMap importieren. Nach dem Import des Pakets können wir die folgenden Methoden verwenden, um eine TreeMap in Java zu erstellen.

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

Im obigen Code haben wir eine TreeMap namens numbers ohne Parameter erstellt. In diesem Beispiel sind die Elemente in der TreeMap nach natürlicher Ordnung (aufsteigend) sortiert.

aber wir können die Sortierung der Elemente durch Verwendung des Comparator-Interfaces anpassen. Wir werden es in einem späteren Teil dieses Tutorials lernen.

Hier,

• Schlüssel - Ein einzigartiger Identifikator, der verwendet wird, um jedes Element (Wert) im Map zu verknüpfen

• Wert - Das Element im Map, das mit dem Schlüssel verbunden ist

Methoden der TreeMap

Die TreeMap-Klasse bietet verschiedene Methoden, die es uns ermöglichen, Operationen auf dem Mapping auszuführen.

Fügen Sie den Element in TreeMap ein

• put() - Fügen Sie den angegebenen Schlüssel hinzu/Wertzuordnung (Einträge) wird in das Mapping eingefügt

• putAll() - Fügen Sie alle Einträge des angegebenen Mappings zu diesem Mapping hinzu

• putIfAbsent() - Fügen Sie den angegebenen Schlüssel hinzu, wenn der Mapping den angegebenen Schlüssel nicht enthält/Wertzuordnung wird in das Map eingefügt

例如，

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Erstellen Sie TreeMap der geraden Zahlen
　　　　　　　　TreeMap<String, Integer> evenNumbers = new TreeMap<>();
　　　　　　　　//　Verwenden Sie put()
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　//　Verwenden Sie putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Six",　6);
　　　　　　　　System.out.println("Die TreeMap der geraden Zahlen: "　+　evenNumbers);
　　　　　　　　//Erstellen Sie TreeMap der Zahlen
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　//　Verwenden Sie putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("TreeMap der Zahlen: "　+　zahlen);
　　　　}
}

Ausgaberesultat

Die TreeMap der geraden Zahlen: {Four=4, Six=6, Two=2}
TreeMap der Zahlen: {Four=4, One=1, Six=6, Two=2}

Zugriff auf TreeMap-Elemente

1.Verwenden Sie entrySet(), keySet() und values(), um auf die Elemente von TreeMap zuzugreifen

• entrySet() - Geben Sie alle Schlüssel von TreeMap zurück/Sammlung der Wertzuordnungen (Einträge)

• keySet() - Geben Sie alle Schlüsselkollaktionen von TreeMap zurück

• values() - Geben Sie alle Sammlungen der Graphen von TreeMap zurück

例如，

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: "　+　zahlen);
　　　　　　　　//　Verwenden Sie entrySet()
　　　　　　　　System.out.println("Schlüssel"/Wertzuordnung: "　+　numbers.entrySet());
　　　　　　　　//　Verwenden Sie keySet()
　　　　　　　　System.out.println("Schlüssel: "　+　numbers.keySet());
　　　　　　　　//　Verwenden Sie values()
　　　　　　　　System.out.println("Werte: ")　+　numbers.values());
　　　　}
}

Ausgaberesultat

TreeMap: {One=1, Three=3, Two=2}
Schlüssel/Wert Abbildung: [One=1, Three=3, Two=2]
Schlüssel: [One, Three, Two]
Werte: [1,　3,　2]

2.Verwenden Sie get() und getOrDefault()

• get() - Geben Sie den mit dem angegebenen Schlüssel verknüpften Wert zurück. Wenn der Schlüssel nicht gefunden wird, geben Sie null zurück.

• getOrDefault() - Geben Sie den mit dem angegebenen Schlüssel verknüpften Wert zurück. Wenn der Schlüssel nicht gefunden wird, geben Sie den angegebenen Standardwert zurück.

例如，

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: "　+　zahlen);
　　　　　　　　//　Verwenden Sie get()
　　　　　　　　int value1　= numbers.get("Three");
　　　　　　　　System.out.println("Verwenden Sie get(): ")　+　value1);
　　　　　　　　//　Verwenden Sie getOrDefault()
　　　　　　　　int value2　= numbers.getOrDefault("Five",　5);
　　　　　　　　System.out.println("Verwenden Sie getOrDefault(): ")　+　value2);
　　　　}
}

Ausgaberesultat

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

Löschen Sie das TreeMap-Element

• remove(key) - Geben Sie den mit dem angegebenen Schlüssel verknüpften Eintrag aus der TreeMap zurück und löschen Sie ihn

• remove(key, value) -Löschen Sie den Eintrag aus der Abbildung, wenn der angegebene Schlüssel mit dem angegebenen Wert verknüpft ist, und geben Sie den booleschen Wert zurück

例如，

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: "　+　zahlen);
　　　　　　　　//Methode zum Löschen mit einem Parameter
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("Gelöschter Wert: ")　+　value);
　　　　　　　　//Methode zum Löschen mit zwei Parametern
　　　　　　　　boolean result = numbers.remove("Three",　3);
　　　　　　　　System.out.println("Eintrag {Three=")3} wurde gelöscht? "　+　result);
　　　　　　　　System.out.println("Aktualisierte TreeMap: ");　+　zahlen);
　　　　}
}

Ausgaberesultat

TreeMap: {One=1, Three=3, Two=2}
Gelöschter Wert =　2
Eintrag {Three=3} wurde gelöscht? True
Aktualisierte TreeMap: {One=1}

Ersetzen Sie das TreeMap-Element

• replace(key, value)-Verwenden Sie key, um den neuen Wert zu ersetzen, der mit der angegebenen Zuordnung value verknüpft ist

• replace(key, old, new) -Ersetzen Sie den alten Wert nur, wenn der alte Wert bereits mit dem angegebenen Schlüssel verknüpft ist.

• replaceAll(function) -Ersetzen Sie jeden Wert der Map mit einer bestimmten Funktion function

例如，

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　zahlen.put("First",　1);
　　　　　　　　zahlen.put("Second",　2);
　　　　　　　　zahlen.put("Third",　3);
　　　　　　　　System.out.println("Ursprüngliche TreeMap: " );　+　zahlen);
　　　　　　　　//　Verwenden Sie "replace()";
　　　　　　　　numbers.replace("Second",　22);
　　　　　　　　numbers.replace("Third",　3,　33);
　　　　　　　　System.out.println("TreeMap verwendet die Methode replace(): " );　+　zahlen);
　　　　　　　　//　Verwenden Sie "replaceAll()";
　　　　　　　　numbers.replaceAll((key, oldValue)　-> oldValue　+　2);
　　　　　　　　System.out.println("TreeMap verwendet die Methode replaceAll(): " );　+　zahlen);
　　　　}
}

Ausgaberesultat

Ursprüngliche TreeMap: {First=1,　Second=2, Third=3}
TreeMap verwendet die Methode replace(): {First=1,　Second=22, Third=33}
TreeMap verwendet die Methode replaceAll(): {First=3,　Second=24, Third=35}

Beachten Sie im obigen Programm die Anweisung

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

Hier übermitteln wir einenLambda-AusdruckAls Parameter.

Die Methode replaceAll() geht alle Einträge der Map ab. Anschließend werden alle Elemente durch neue Werte ersetzt (von Lambda-Ausdrücken zurückgegeben).

Navigation Methoden

Da die TreeMap-Klasse NavigableMap implementiert, bietet sie verschiedene Methoden zur Navigation durch die TreeMap-Elemente.

1.Erste und letzte Methoden

• firstKey() - Gibt den ersten Schlüssel der Map zurück

• firstEntry() - Gibt den Schlüssel des ersten Elements der Zuordnung zurück/Wertzuordnung

• lastKey() - Gibt den letzten Schlüssel der Map zurück

• lastEntry() - Gibt den Schlüssel des letzten Elements der Zuordnung zurück/Wertzuordnung

例如，

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　zahlen.put("First",　1);
　　　　　　　　zahlen.put("Second",　2);
　　　　　　　　zahlen.put("Third",　3);
　　　　　　　　System.out.println("TreeMap: "　+　zahlen);
　　　　　　　　//　Verwenden Sie die Methode "firstKey()";
　　　　　　　　String firstKey = numbers.firstKey();
　　　　　　　　System.out.println("Erster Schlüssel: " );　+　firstKey);
　　　　　　　　//　Verwenden Sie die Methode "lastKey()";
　　　　　　　　String lastKey = numbers.lastKey();
　　　　　　　　System.out.println("Letzter Schlüssel: " );　+　lastKey);
　　　　　　　　//　Verwenden Sie die Methode "firstEntry()";
　　　　　　　　System.out.println("Erstes Element: " );　+　numbers.firstEntry());
　　　　　　　　//　Verwendung der Methode the lastEntry()
　　　　　　　　System.out.println("Letztes Element: ");　+　numbers.lastEntry());
　　　　}
}

Ausgaberesultat

TreeMap: {First=1,　Second=2, Third=3}
Erster Schlüssel: First
Letzter Schlüssel: Third
Erstes Element: First=1
Letztes Element: Third=3

2.Nach oben, nach unten, obere und untere Grenzen Methoden

• HigherKey(); - Rückgabe des kleinsten Schlüssels, der größer als der angegebene Schlüssel ist.

• HigherEntry(); - Rückgabe des Eintrags, der mit dem kleinsten Schlüssel verbunden ist, der größer als der angegebene Schlüssel ist.

• lowerKey(); - Rückgabe des größten Schlüssels, der kleiner als der angegebene Schlüssel ist.

• lowerEntry(); - Rückgabe des Eintrags, der mit dem größten Schlüssel verbunden ist, der kleiner als der angegebene Schlüssel ist.

• ceilingKey(); - Rückgabe des kleinsten Schlüssels, der größer als der angegebene Schlüssel ist. Wenn im Mapping ein als Parameter übergebener Schlüssel existiert, wird dieser Schlüssel zurückgegeben.

• ceilingEntry(); - Rückgabe des Eintrags, der mit dem kleinsten Schlüssel verbunden ist, der größer als der angegebene Schlüssel ist. Wenn im Mapping ein Eintrag mit dem Schlüssel, der an den Argumenten übergeben wird, verknüpft ist, wird dieser Eintrag zurückgegeben.

• floorKey(); - Rückgabe des größten Schlüssels, der kleiner als der angegebene Schlüssel ist. Wenn als Parameter ein Schlüssel übergeben wird, wird dieser Schlüssel zurückgegeben.

• floorEntry(); - Rückgabe des Eintrags, der mit dem größten Schlüssel verbunden ist, der kleiner als der angegebene Schlüssel ist. Wenn als Parameter ein Schlüssel übergeben wird, wird dieser Schlüssel zurückgegeben.

例如，

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

Ausgaberesultat

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

3. pollFirstEntry() und pollLastEntry() Methoden

• pollFirstEntry() - Gibt und löscht den Eintrag, der mit dem ersten Schlüssel der Abbildung verbunden ist

• pollLastEntry()　 -Gibt und löscht den Eintrag, der mit dem letzten Schlüssel der Abbildung verbunden ist

例如，

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　zahlen.put("First",　1);
　　　　　　　　zahlen.put("Second",　2);
　　　　　　　　zahlen.put("Third",　3);
　　　　　　　　System.out.println("TreeMap: "　+　zahlen);
　　　　　　　　//Verwenden Sie den pollFirstEntry() Methoden
　　　　　　　　System.out.println("Verwenden Sie pollFirstEntry(): ");　+　numbers.pollFirstEntry());
　　　　　　　　//　Verwenden Sie den pollLastEntry() Methoden
　　　　　　　　System.out.println("Verwenden Sie pollLastEntry(): ");　+　numbers.pollLastEntry());
　　　　　　　　System.out.println("Aktualisierte TreeMap: ");　+　zahlen);
　　　　}
}

Ausgaberesultat

TreeMap: {First=1,　Second=2, Third=3}
Verwenden Sie pollFirstEntry(): First=1
Verwenden Sie pollLastEntry(): Third=3
Aktualisierte TreeMap: {Second=2}

4. headMap(), tailMap() und subMap() Methoden

headMap(key, booleanValue)

Der Parameter booleanValue ist optional. Der Standardwert ist false.

Wenn booleanValue wahr ist, umfasst diese Methode auch den angegebenen Schlüssel/值对。

例如，

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　zahlen.put("First",　1);
　　　　　　　　zahlen.put("Second",　2);
　　　　　　　　zahlen.put("Third",　3);
　　　　　　　　zahlen.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　zahlen);
　　　　　　　　System.out.println("\nVerwenden Sie die Methode headMap() ");
　　　　　　　　//　headMap() 使用默认 booleanValue为false
　　　　　　　　System.out.println("没有指定布尔值:　"　+　numbers.headMap("Fourth"));
　　　　　　　　//　headMap()使用指定　booleanValue　为　true
　　　　　　　　System.out.println("指定布尔值为true:　"　+　numbers.headMap("Fourth", true));
　　　　}
}

Ausgaberesultat

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，则该方法不包含指定key的键/值对。

例如，

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

Ausgaberesultat

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<>();
　　　　　　　　zahlen.put("First",　1);
　　　　　　　　zahlen.put("Second",　2);
　　　　　　　　zahlen.put("Third",　3);
　　　　　　　　zahlen.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　zahlen);
　　　　　　　　System.out.println("\nVerwenden Sie die Methode subMap():");
　　　　　　　　//　tailMap() mit Standard-Boolean-Wert
　　　　　　　　System.out.println("Verwenden Sie den Standard-Boolean-Wert: "　+　zahlen.subMap("Fourth", "Third"));
　　　　　　　　//　tailMap() mit angegebenem Boolean-Wert
　　　　　　　　System.out.println("Bestimmen Sie den Boolean-Wert: "　+　zahlen.subMap("Fourth", false, "Third", true));
　　　　}
}

Ausgaberesultat

TreeMap: {First=1,　Fourth=2,　Second=2, Third=3}
Verwenden Sie die Methode subMap():
Verwenden Sie den Standard-Boolean-Wert: {Fourth=4,　Second=2}
Bestimmen Sie den Boolean-Wert: {Second=2, Third=3}

Andere Methoden von TreeMap

TreeMap-Vergleichsmerker

In allen obigen Beispielen werden die TreeMap-Elemente natürlich sortiert (in aufsteigender Reihenfolge). Aber wir können auch die Reihenfolge der Schlüssel selbst definieren.

Daher müssen wir eine eigene Vergleichsmerkerklasse basierend auf der Sortierung der Schlüssel im Baumdiagramm erstellen. Zum Beispiel,

import java.util.TreeMap;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Erstellen Sie einen TreeMap mit einem benutzerdefinierten Vergleichsmerker
　　　　　　　　TreeMap<String, Integer> zahlen = new TreeMap<>(new CustomComparator());
　　　　　　　　zahlen.put("First",　1);
　　　　　　　　zahlen.put("Second",　2);
　　　　　　　　zahlen.put("Third",　3);
　　　　　　　　zahlen.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　zahlen);
　　　　}
　　　　//Erstellen Sie eine Vergleichsklasse
　　　　public static class CustomComparator implements Comparator<String> {
　　　　　　　　@Override
　　　　　　　　public　int　compare(String　number1,　String　number2)　{
　　　　　　　　　　　　int　value　=　　number1.compareTo(number2);
　　　　　　　　　　　　//Die Elemente werden in umgekehrter Reihenfolge sortiert
　　　　　　　　　　　　if　(value　>　0)　{
　　　　　　　　　　　　　　　　return　-1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else　if　(value　<　0)　{
　　　　　　　　　　　　　　　　return　1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else　{
　　　　　　　　　　　　　　　　return　0;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

Ausgaberesultat

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

Im obigen Beispiel haben wir einen TreeMap erstellt und die CustomComparator-Klasse als Parameter übergeben.

Die CustomComparator-Klasse implementiert das Comparator-Interface.

Dann überschreibe die compare() Methode, um die Elemente in umgekehrter Reihenfolge anzuordnen.