Java Map Interface

In diesem Tutorial werden wir die Java Map-Schnittstelle und ihre Methoden lernen.

Der Map-Schnittstelle der Java Collections Framework bietet die Funktionen der Map-Datenstruktur.

es implementiert das Collection-Interface.

Arbeitsablauf von Map

In Java werden Map-Elemente im Schlüssel/in Wertepaaren. Der Schlüssel ist der einzigartige Wert, der mit den verschiedenen Werten verknüpft ist.

Map-Sammlungen können keine wiederholten Schlüssel enthalten. Und jeder Schlüssel ist mit einem Wert verknüpft.

Wir können die mit ihnen verbundenen Schlüssel verwenden, um auf die Werte zuzugreifen und zu ändern.

Im obigen Bild haben wir Werte: Vereinigte Staaten, Brasilien und Spanien. Wir haben die entsprechenden Schlüssel: us, br und es.

Jetzt können wir die entsprechenden Schlüssel verwenden, um auf diese Werte zuzugreifen.

Achtung:Map-Schnittstelle verwaltet3unterschiedliche Sammlungen:

• Schlüsselmenge

• Wertesammlung

• Schlüssel/Sammlung von Werteverknüpfungen (Map-Sammlung).

Daher können wir die Schlüssel, Werte und Verknüpfungen getrennt ansprechen.

Klassen, die Map implementieren

Da Map ein Interface ist, kann aus ihm kein Objekt erstellt werden.

Um die Funktionen des Map-Interfaces zu verwenden, können wir folgende Klassen verwenden:

• HashMap

• EnumMap

• LinkedHashMap

• WeakHashMap

• TreeMap

Diese Klassen sind im Sammlungsrahmen definiert und implementieren das Map-Interface.

Interfaces, die Map ableiten

Das Map-Interface wird auch von folgenden Unter-Interfaces abgeleitet:

• SortedMap

• NavigableMap

• ConcurrentMap

Wie verwendet man Map?

In Java müssen wir das Paket java.util.Map importieren, um das Map-Interface verwenden zu können. Nach dem Importieren des Pakets wird der Map wie folgt erstellt.

//Erstellen Sie eine Map mit der HashMap-Klasse
Map<Key, Value> numbers = new HashMap<>();

In obigem Code haben wir eine Map namens numbers erstellt. Wir haben die HashMap-Klasse verwendet, um das Map-Interface zu implementieren.

Hier,

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

• Wert - Elemente, die mit dem Schlüssel in der Map verknüpft sind

map-Methode

Das Map-Interface umfasst alle Methoden des Collection-Interfaces. Dies liegt daran, dass Collection das Super-Interface von Map ist.

Neben den Methoden, die im Collection-Interface verfügbar sind, umfasst das Map-Interface auch folgende Methoden:

• put(K,V) - Fügen Sie die Verknüpfung zwischen dem Schlüssel K und dem Wert V in die Map ein. Wenn der Schlüssel bereits existiert, wird der alte Wert durch den neuen ersetzt.

• putAll() - Fügen Sie alle Einträge aus der angegebenen Map-Sammlung in diese Map-Sammlung ein.

• putIfAbsent(K,V) - Fügen Sie eine Verknüpfung V hinzu, wenn der Schlüssel K noch nicht mit einem Wert verbunden ist.

• get(K) - Geben Sie den Wert zurück, der mit dem angegebenen Schlüssel K verbunden ist. Wenn der Schlüssel nicht gefunden wird, wird null zurückgegeben.

• getOrDefault(K,defaultValue) - Geben Sie den Wert zurück, der mit dem angegebenen Schlüssel K verbunden ist. Wenn der Schlüssel nicht gefunden wird, wird defaultValue zurückgegeben.

• containsKey(K） - Überprüfen Sie, ob der angegebene Schlüssel K in der Map existiert.

• containsValue(V) - Überprüfen Sie, ob der angegebene Wert V in der Map existiert.

• replace(K,V) - Ersetzen Sie den Wert des Schlüssels K durch den neuen angegebenen Wert V.

• replace(K,oldValue,newValue) - Ersetzen Sie den Wert des Schlüssels K nur, wenn er mit dem alten Wert oldValue verbunden ist, durch den neuen Wert newValue.

• remove(K) - Entfernen Sie den Eintrag aus der Map, der durch den Schlüssel K dargestellt wird.

• remove(K,V) - Entfernen Sie den Eintrag, der mit dem Schlüssel K und dem Wert V verbunden ist, aus der Map-Sammlung...

• keySet() -Gibt eine Sammlung aller vorhandenen Schlüssel der Map zurück.

• values() -Gibt eine Gruppe von Werten zurück, die in der Map-Sammlung enthalten sind.

• entrySet() -Gibt alle vorhandenen Schlüssel der Map zurück/Sammlung der Wertzuordnung.

Map-Interface-Implementierung

1.Implementiere HashMap-Klasse

import java.util.Map;
import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Erstelle eine Map mit HashMap-Klasse
　　　　　　　　Map<String, Integer> numbers = new HashMap<>();
　　　　　　　　//Füge Elemente in die Map-Sammlung ein
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　System.out.println("Map: ")　+　numbers);
　　　　　　　　//Schlüssel der Map
　　　　　　　　System.out.println("Schlüssel: ")　+　numbers.keySet());
　　　　　　　　//Werte der Map
　　　　　　　　System.out.println("Werte: ")　+　numbers.values());
　　　　　　　　//Einträge der Map
　　　　　　　　System.out.println("Einträge: ")　+　numbers.entrySet());
　　　　　　　　//Element aus Map-Sammel删除
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("Der gelöschte Wert ist: ")　+　value);
　　　　}
}

Ausgabefolge

Map: {One=1, Two=2}
Schlüssel: [One, Two]
Werte: [1,　2]
Einträge: [One=1, Two=2]
Der gelöschte Wert ist:　2

Um mehr über HashMap zu erfahren, besucheJava HashMap.

2.Implementiere TreeMap-Klasse

import java.util.Map;
import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Erstelle eine Map mit TreeMap
　　　　　　　　Map<String, Integer> values = new TreeMap<>();
　　　　　　　　//Füge Elemente in die Map ein
　　　　　　　　values.put("Second",　2);
　　　　　　　　values.put("First",　1);
　　　　　　　　System.out.println("Verwende TreeMap, um eine Map zu erstellen: "　+　values);
　　　　　　　　//Ersatzwert
　　　　　　　　values.replace("First",　11);
　　　　　　　　values.replace("Second",　22);
　　　　　　　　System.out.println("Neues Map:　"　+　values);
　　　　　　　　//Element aus Map-Sammel删除
　　　　　　　　int removedValue = values.remove("First");
　　　　　　　　System.out.println("Gelöschter Wert:　"　+　removedValue);
　　　　}
}

Ausgabefolge

Map mit TreeMap erstellen:　{First=1, Second=2}
Neues Map:　{First=11, Second=22}
Gelöschter Wert:　11

Für weitere Informationen über TreeMap besuchen Sie bitteJava TreeMap.