Java-Baumkarte
Java TreeMap
In diesem Tutorial lernen wir die Java TreeMap-Klasse und ihre Operationen anhand von Beispielen kennen.
Der TreeMap Klasse des Java Collections Framework stellt die Implementierung der Baumdatenstruktur bereit.
Es implementiert die NavigableMap-Schnittstelle.
Baumkarte erstellen
Um eine TreeMap zu erstellen , müssen wir den java.util.TreeMap importieren Paket zuerst. Nachdem wir das Paket importiert haben, können wir wie folgt einen TreeMap erstellen in Java.
TreeMap<Key, Value> numbers = new TreeMap<>();
Im obigen Code haben wir einen TreeMap erstellt benannte Zahlen ohne Argumente. In diesem Fall die Elemente in TreeMap werden natürlich (aufsteigend) sortiert.
Wir können jedoch die Sortierung der Elemente anpassen, indem wir den Comparator verwenden Schnittstelle. Wir werden später in diesem Tutorial mehr darüber erfahren.
Hier,
- Schlüssel - eine eindeutige Kennung, die verwendet wird, um jedes Element (Wert) in einer Zuordnung zuzuordnen
- Wert - Elemente, die durch Schlüssel in einer Karte verknüpft sind
Methoden von TreeMap
Die TreeMap Die Klasse bietet verschiedene Methoden, mit denen wir Operationen auf der Karte ausführen können.
Elemente in TreeMap einfügen
put()- fügt die angegebene Schlüssel/Wert-Zuordnung (Eintrag) in die Zuordnung einputAll()- fügt alle Einträge aus der angegebenen Map in diese Map einputIfAbsent()- fügt die angegebene Schlüssel/Wert-Zuordnung in die Map ein, wenn der angegebene Schlüssel nicht in der Map vorhanden ist
Zum Beispiel
import java.util.TreeMap;
class Main {
public static void main(String[] args) {
// Creating TreeMap of even numbers
TreeMap<String, Integer> evenNumbers = new TreeMap<>();
// Using put()
evenNumbers.put("Two", 2);
evenNumbers.put("Four", 4);
// Using putIfAbsent()
evenNumbers.putIfAbsent("Six", 6);
System.out.println("TreeMap of even numbers: " + evenNumbers);
//Creating TreeMap of numbers
TreeMap<String, Integer> numbers = new TreeMap<>();
numbers.put("One", 1);
// Using putAll()
numbers.putAll(evenNumbers);
System.out.println("TreeMap of numbers: " + numbers);
}
}
Ausgabe
TreeMap of even numbers: {Four=4, Six=6, Two=2}
TreeMap of numbers: {Four=4, One=1, Six=6, Two=2}
Zugriff auf TreeMap-Elemente
1. Mit entrySet(), keySet() und values()
entrySet()- gibt einen Satz aller Schlüssel/Werte-Mappings (Einträge) einer Treemap zurückkeySet()- gibt einen Satz aller Schlüssel einer Baumkarte zurückvalues()- gibt einen Satz aller Karten einer Baumkarte zurück
Zum Beispiel
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);
// Using entrySet()
System.out.println("Key/Value mappings: " + numbers.entrySet());
// Using keySet()
System.out.println("Keys: " + numbers.keySet());
// Using values()
System.out.println("Values: " + numbers.values());
}
}
Ausgabe
TreeMap: {One=1, Three=3, Two=2}
Key/Value mappings: [One=1, Three=3, Two=2]
Keys: [One, Three, Two]
Values: [1, 3, 2]
2. Verwendung von get() und getOrDefault()
get()- Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist. Gibt null zurück, wenn der Schlüssel nicht gefunden wird.getOrDefault()- Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist. Gibt den angegebenen Standardwert zurück, wenn der Schlüssel nicht gefunden wird.
Zum Beispiel
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);
// Using get()
int value1 = numbers.get("Three");
System.out.println("Using get(): " + value1);
// Using getOrDefault()
int value2 = numbers.getOrDefault("Five", 5);
System.out.println("Using getOrDefault(): " + value2);
}
}
Ausgabe
TreeMap: {One=1, Three=3, Two=2}
Using get(): 3
Using getOrDefault(): 5
Hier der getOrDefault() -Methode findet den Schlüssel Five nicht . Daher gibt es den angegebenen Standardwert 5 zurück .
TeeMap-Elemente entfernen
remove(key)- Gibt den mit dem angegebenen Schlüssel verknüpften Eintrag aus einer TreeMap zurück und entfernt ihn.remove(key, value)- entfernt den Eintrag nur dann aus der Map, wenn der angegebene Schlüssel mit dem angegebenen Wert verknüpft ist, und gibt einen booleschen Wert zurück
Zum Beispiel
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);
// remove method with single parameter
int value = numbers.remove("Two");
System.out.println("Removed value: " + value);
// remove method with two parameters
boolean result = numbers.remove("Three", 3);
System.out.println("Is the entry {Three=3} removed? " + result);
System.out.println("Updated TreeMap: " + numbers);
}
}
Ausgabe
TreeMap: {One=1, Three=3, Two=2}
Removed value = 2
Is the entry {Three=3} removed? True
Updated TreeMap: {One=1}
TreeMap-Elemente ersetzen
replace(key, value)- ersetzt den durch den angegebenen key abgebildeten Wert mit dem neuen Wertreplace(key, old, new)- ersetzt den alten Wert nur dann durch den neuen Wert, wenn der alte Wert bereits mit dem angegebenen Schlüssel verknüpft istreplaceAll(function)- ersetzt jeden Wert der Karte durch das Ergebnis der angegebenen Funktion
Zum Beispiel
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("Original TreeMap: " + numbers);
// Using replace()
numbers.replace("Second", 22);
numbers.replace("Third", 3, 33);
System.out.println("TreeMap using replace: " + numbers);
// Using replaceAll()
numbers.replaceAll((key, oldValue) -> oldValue + 2);
System.out.println("TreeMap using replaceAll: " + numbers);
}
}
Ausgabe
Original TreeMap: {First=1, Second=2, Third=3}
TreeMap using replace(): {First=1, Second=22, Third=33}
TreeMap using replaceAll(): {First=3, Second=24, Third=35}
Beachten Sie im obigen Programm die Anweisung
numbers.replaceAll((key, oldValue) -> oldValue + 2);
Hier haben wir einen Lambda-Ausdruck als Argument übergeben.
Die replaceAll() -Methode greift auf alle Einträge der Map zu. Anschließend werden alle Elemente durch die neuen Werte ersetzt (die vom Lambda-Ausdruck zurückgegeben werden).
Navigationsmethoden
Seit TreeMap Klasse implementiert NavigableMap , bietet es verschiedene Methoden, um über die Elemente der Baumkarte zu navigieren.
1. Erste und letzte Methode
firstKey()- gibt den ersten Schlüssel der Karte zurückfirstEntry()- gibt die Schlüssel/Wert-Zuordnung des ersten Schlüssels der Zuordnung zurücklastKey()- gibt den letzten Schlüssel der Karte zurücklastEntry()- gibt die Schlüssel/Wert-Zuordnung des letzten Schlüssels der Zuordnung zurück
Zum Beispiel
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);
// Using the firstKey() method
String firstKey = numbers.firstKey();
System.out.println("First Key: " + firstKey);
// Using the lastKey() method
String lastKey = numbers.lastKey();
System.out.println("Last Key: " + lastKey);
// Using firstEntry() method
System.out.println("First Entry: " + numbers.firstEntry());
// Using the lastEntry() method
System.out.println("Last Entry: " + numbers.lastEntry());
}
}
Ausgabe
TreeMap: {First=1, Second=2, Third=3}
First Key: First
Last Key: Third
First Entry: First=1
Last Entry: Third=3
2. Decken-, Boden-, höhere und niedrigere Methoden
- higherKey() - Gibt den niedrigsten Schlüssel unter den Schlüsseln zurück, die größer als der angegebene Schlüssel sind.
- höhererEintrag() - Gibt einen Eintrag zurück, der einem Schlüssel zugeordnet ist, der unter allen Schlüsseln der niedrigste ist, der größer als der angegebene Schlüssel ist.
- lowerKey() - Gibt den größten Schlüssel unter allen Schlüsseln zurück, die kleiner als der angegebene Schlüssel sind.
- untererEintrag() - Gibt einen Eintrag zurück, der einem Schlüssel zugeordnet ist, der unter allen Schlüsseln, die kleiner als der angegebene Schlüssel sind, am größten ist.
- ceilingKey() - Gibt den niedrigsten Schlüssel unter den Schlüsseln zurück, die größer als der angegebene Schlüssel sind. Wenn der als Argument übergebene Schlüssel in der Zuordnung vorhanden ist, wird dieser Schlüssel zurückgegeben.
- CeilingEntry() - Gibt einen Eintrag zurück, der einem Schlüssel zugeordnet ist, der unter den Schlüsseln, die größer als der angegebene Schlüssel sind, am niedrigsten ist. Wenn ein Eintrag, der mit dem Schlüssel verbunden ist, an den ein Argument übergeben wurde, in der Map vorhanden ist, gibt sie den mit diesem Schlüssel verbundenen Eintrag zurück.
- floorKey() - Gibt den größten Schlüssel unter den Schlüsseln zurück, die kleiner als der angegebene Schlüssel sind. Wenn der als Argument übergebene Schlüssel vorhanden ist, wird dieser Schlüssel zurückgegeben.
- floorEntry() - Gibt einen Eintrag zurück, der einem Schlüssel zugeordnet ist, der unter den Schlüsseln, die kleiner als der angegebene Schlüssel sind, am größten ist. Wenn der als Argument übergebene Schlüssel vorhanden ist, wird dieser Schlüssel zurückgegeben.
Zum Beispiel
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);
// Using higher()
System.out.println("Using higherKey(): " + numbers.higherKey("Fourth"));
System.out.println("Using higherEntry(): " + numbers.higherEntry("Fourth"));
// Using lower()
System.out.println("\nUsing lowerKey(): " + numbers.lowerKey("Fourth"));
System.out.println("Using lowerEntry(): " + numbers.lowerEntry("Fourth"));
// Using ceiling()
System.out.println("\nUsing ceilingKey(): " + numbers.ceilingKey("Fourth"));
System.out.println("Using ceilingEntry(): " + numbers.ceilingEntry("Fourth"));
// Using floor()
System.out.println("\nUsing floorKey(): " + numbers.floorKey("Fourth"));
System.out.println("Using floorEntry(): " + numbers.floorEntry("Fourth"));
}
}
Ausgabe
TreeMap: {First=1, Fourth=6, Second=5, Third=4}
Using higherKey(): Second
Using higherEntry(): Second=5
Using lowerKey(): First
Using lowerEntry(): First=1
Using ceilingKey(): Fourth
Using ceilingEntry(): Fourth=6
Using floorkey(): Fourth
Using floorEntry(): Fourth=6
3. pollFirstEntry()- und pollLastEntry()-Methoden
pollFirstEntry()- gibt den mit dem ersten Schlüssel der Map verknüpften Eintrag zurück und entfernt ihnpollLastEntry()- gibt den mit dem letzten Schlüssel der Map verknüpften Eintrag zurück und entfernt ihn
Zum Beispiel
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);
//Using the pollFirstEntry() method
System.out.println("Using pollFirstEntry(): " + numbers.pollFirstEntry());
// Using the pollLastEntry() method
System.out.println("Using pollLastEntry(): " + numbers.pollLastEntry());
System.out.println("Updated TreeMap: " + numbers);
}
}
Ausgabe
TreeMap: {First=1, Second=2, Third=3}
Using pollFirstEntry(): First=1
Using pollLastEntry(): Third=3
Updated TreeMap: {Second=2}
4. headMap()-, tailMap()- und subMap()-Methoden
headMap(Schlüssel, boolescher Wert)
Der headMap() -Methode gibt alle Schlüssel/Wert-Paare einer Baumkarte vor dem angegebenen Schlüssel zurück (das als Argument übergeben wird).
Der boolesche Wert Parameter ist optional. Sein Standardwert ist false .
Wenn true wird als booleanValue übergeben enthält die Methode auch das Schlüssel/Wert-Paar des key die als Argument übergeben wird.
Zum Beispiel
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("\nUsing headMap() Method:");
// Using headMap() with default booleanValue
System.out.println("Without boolean value: " + numbers.headMap("Fourth"));
// Using headMap() with specified booleanValue
System.out.println("With boolean value: " + numbers.headMap("Fourth", true));
}
}
Ausgabe
TreeMap: {First=1, Fourth=4, Second=2, Third=3}
Using headMap() Method:
Without boolean value: {First=1}
With boolean value: {First=1, Fourth=4}
tailMap(Schlüssel, boolescher Wert)
Der tailMap() -Methode gibt alle Schlüssel/Wert-Paare einer Baumkarte ab dem angegebenen Schlüssel zurück (das als Argument übergeben wird).
Der boolesche Wert ist ein optionaler Parameter. Sein Standardwert ist true .
Wenn false wird als booleanValue übergeben enthält die Methode das Schlüssel/Wert-Paar des angegebenen key nicht .
Zum Beispiel
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("\nUsing tailMap() Method:");
// Using tailMap() with default booleanValue
System.out.println("Without boolean value: " + numbers.tailMap("Second"));
// Using tailMap() with specified booleanValue
System.out.println("With boolean value: " + numbers.tailMap("Second", false));
}
}
Ausgabe
TreeMap: {First=1, Fourth=4, Second=2, Third=3}
Using tailMap() Method:
Without boolean value: {Second=2, Third=3}
With boolean value: {Third=3}
subMap(k1, bV1, k2, bV2)
Der subMap() -Methode gibt alle Einträge zurück, die Schlüsseln zwischen k1 zugeordnet sind und k2 einschließlich des Eintrags von k1 .
Der bV1 und bV2 sind optionale boolesche Parameter. Der Standardwert von bV1 ist true und dem Standardwert von bV2 ist false .
Wenn false wird als bV1 übergeben , gibt die Methode alle Einträge zurück, die Schlüsseln zwischen k1 zugeordnet sind und k2 ohne den Eintrag von k1 einzuschließen .
Wenn true wird als bV2 übergeben , gibt die Methode alle Einträge zurück, die Schlüsseln zwischen k1 zugeordnet sind und k2 einschließlich des Eintrags von k2 .
Zum Beispiel
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("\nUsing subMap() Method:");
// Using subMap() with default booleanValue
System.out.println("Without boolean value: " + numbers.subMap("Fourth", "Third"));
// Using subMap() with specified booleanValue
System.out.println("With boolean value: " + numbers.subMap("Fourth", false, "Third", true));
}
}
Ausgabe
TreeMap: {First=1, Fourth=2, Second=2, Third=3}
Using subMap() Method:
Without boolean value: {Fourth=4, Second=2}
With boolean value: {Second=2, Third=3}
Andere Methoden von TreeMap
| Methode | Beschreibung |
|---|---|
clone() | Erzeugt eine Kopie von TreeMap |
containsKey() | Sucht nach TreeMap für den angegebenen Schlüssel und gibt ein boolesches Ergebnis | zurück
containsValue() | Sucht nach TreeMap für den angegebenen Wert und gibt ein boolesches Ergebnis | zurück
size() | Gibt die Größe des TreeMap zurück |
clear() | Entfernt alle Einträge aus TreeMap |
TreeMap-Komparator
In allen obigen Beispielen werden Treemap-Elemente natürlich (in aufsteigender Reihenfolge) sortiert. Wir können jedoch auch die Reihenfolge der Schlüssel anpassen.
Dazu müssen wir unsere eigene Komparatorklasse erstellen, basierend darauf, welche Schlüssel in einer Baumkarte sortiert sind. Zum Beispiel
import java.util.TreeMap;
import java.util.Comparator;
class Main {
public static void main(String[] args) {
// Creating a treemap with a customized comparator
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);
}
// Creating a comparator class
public static class CustomComparator implements Comparator<String> {
@Override
public int compare(String number1, String number2) {
int value = number1.compareTo(number2);
// elements are sorted in reverse order
if (value > 0) {
return -1;
}
else if (value < 0) {
return 1;
}
else {
return 0;
}
}
}
}
Ausgabe
TreeMap: {Third=3, Second=2, Fourth=4, First=1}
Im obigen Beispiel haben wir eine Baumkarte erstellt, die CustomComparator übergibt Klasse als Argument.
Der CustomComparator Klasse implementiert den Comparator Schnittstelle.
Wir überschreiben dann den compare() Methode, um Elemente in umgekehrter Reihenfolge zu sortieren.
Um mehr zu erfahren, besuchen Sie Java Comparator (offizielle Java-Dokumentation).
Java