Java Map Interface Tutorial mit Implementierung und Beispielen

java map interface tutorial with implementation examples

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Wählen Sie Das Betriebssystem Aus Wählen Sie Ein Projektionsprogramm (Optional)

Beschreiben Sie Ihr Problem

In diesem umfassenden Java Map-Lernprogramm wird das Erstellen, Initialisieren und Durchlaufen von Karten beschrieben. Außerdem erfahren Sie mehr über Kartenmethoden und Implementierungsbeispiele:

Sie lernen die Grundlagen der Kartenschnittstelle, die von der Kartenschnittstelle unterstützten Methoden und andere spezifische Begriffe im Zusammenhang mit der Kartenschnittstelle kennen.

Die Kartensammlung in Java ist eine Sammlung, die einen Schlüssel einem Wert zuordnet. Es ist eine Sammlung bestehend aus Schlüsseln und Werten. Jeder Eintrag in der Karte besteht aus einem Schlüssel mit dem entsprechenden Wert. Die Schlüssel sind in Karten eindeutig. Karten können normalerweise verwendet werden, wenn eine Sammlung basierend auf einem Schlüsselwert geändert werden muss.

=> Überprüfen Sie ALLE Java-Tutorials hier.

Kartenschnittstelle in Java

Was du lernen wirst:

Karten in Java
Kartenmethoden
Java Map-Implementierung
Fazit
- Literatur-Empfehlungen

Karten in Java

Die Karte in Java ist Teil der Schnittstelle java.util.map. Die Kartenschnittstelle ist kein Teil der Sammlungsschnittstelle, und aus diesem Grund unterscheiden sich die Karten von den anderen Sammlungen.

Die allgemeine Hierarchie der Kartenschnittstelle ist unten dargestellt.

allgemeine Hierarchie der Kartenschnittstelle

Wie oben gezeigt, gibt es zwei Schnittstellen zum Implementieren der Karte, d. H. Der Kartenschnittstelle und der sortierten Kartenschnittstelle. Es gibt drei Klassen, nämlich HashMap, TreeMap und LinkedHashMap.

Diese Kartentypen werden nachfolgend beschrieben:

Klasse	Beschreibung
entfernen	V entfernen (Objektschlüssel)	Löschen Sie einen Karteneintrag für den angegebenen Schlüssel
LinkedHashMap	Erweitert sich aus der HashMap-Klasse. Diese Karte behält die Einfügereihenfolge bei
HashMap	Implementieren Sie eine Kartenschnittstelle. HashMap verwaltet keine Reihenfolge.
Baumkarte	Implementiert sowohl die Map- als auch die sortierte Map-Schnittstelle. TreeMap behält eine aufsteigende Reihenfolge bei.

Wichtige Punkte zu Karten.

In Karten kann jeder Schlüssel höchstens einem Wert zugeordnet werden. Außerdem dürfen in Karten keine doppelten Schlüssel vorhanden sein.
Map-Implementierungen wie HashMap und LinkedHashMap erlauben Nullschlüssel- und Nullwerte. TreeMap erlaubt dies jedoch nicht.
Eine Karte kann nicht so wie sie ist durchlaufen werden. Daher muss es zum Durchlaufen mit der Methode keyset () oder entrySet () in set konvertiert werden.

Erstellen Sie eine Karte in Java

Um eine Karte in Java zu erstellen, müssen wir zuerst die Schnittstelle in unser Programm aufnehmen. Wir können eine der folgenden Anweisungen im Programm verwenden, um die Kartenfunktionalität zu importieren.

import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap;

Wir müssen eine konkrete Implementierung der Karte instanziieren, da es sich um eine Schnittstelle handelt.

Die folgenden Anweisungen erstellen eine Karte in Java.

Map hash_map = new HashMap(); Map tree_map = new TreeMap();

Mit den obigen Anweisungen werden Karten mit Standardspezifikationen erstellt.
Wir können auch generische Karten erstellen, in denen die Typen für Schlüssel und Wert angegeben sind.

Map myMap = new HashMap();

Die obige Definition enthält Schlüssel vom Typ Zeichenfolge und Objekte als Werte.

Initialisieren Sie eine Karte in Java

Es kann mit den folgenden Methoden initialisiert werden:

# 1) Sammlungen verwenden

Die Java Collections-Klasse verfügt über Factory-Methoden, mit denen Sammlungen einschließlich Karten initialisiert werden können.

Einige Methoden zum Initialisieren der Karte sind wie folgt:

(1) Collections.EmptyMap ()

Die Collections.EmptyMap () gibt eine serialisierbare und unveränderliche Map zurück, die leer ist. Beispielsweise, die folgende Codezeile,

Map myMap = Collections.EMPTY_MAP;

Dadurch wird eine leere Karte erstellt. Die obige Methode kann eine 'ungeprüfte Zuweisungswarnung' auslösen, und daher können wir das typsichere Formular auch wie folgt verwenden.

Map myMap = Collections.emptyMap ();

(2) Collections.unModizableMap ()

Die Methode unModizableMap () verwendet eine andere Karte als Argument und erstellt eine nicht veränderbare Ansicht der ursprünglichen Karte.

Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap);

(3) Collections.singletonMap ()

Die Collections-Klasse bietet auch eine Factory-Methode 'singletonMap ()', mit der eine unveränderliche Singleton-Map mit nur einem Eintrag erstellt wird.

Map singleton_map = Collections.singletonMap('CHN', 'Beijing');

# 2) Verwenden von Java 8

Wir können einen Datenstrom aus Java 8-Stream-API-Methoden abrufen und Karten mit Collectors erstellen.

Einige der Methoden zum Erstellen von Karten sind:

(1) Collectors.toMap ()

Wir sammeln einen Stream und verwenden dann die Collectors.toMap () -Methode, um eine Karte zu erstellen.

 Map map = Stream.of(new String()(){{'USA', 'Washington'},   {'United Kingdom', 'London'}    }).collect(Collectors.toMap(p -> p(0), p -> p(1)));

Die obige Anweisung erstellt eine Karte aus dem Java 8-Stream.

(2) Collectors.collectingAndThen ()

In diesem Fall passen wir die toMap () -Methode an, mit der der Kollektor mithilfe der collectAndThen () -Methode eine unveränderliche Karte erstellen kann.

 Map immutableMap = Stream.of(new String()(){   {'USA', 'Washington'}, {'United Kingdom', 'London”}   }).collect(Collectors.collectingAndThen(Collectors.toMap(p -> p (0), p -> p(1)),   Collections::unmodifiableMap));

# 3) Verwenden der put-Methode der Kartenschnittstelle

Mit der put () -Methode der Kartenschnittstelle können Karten Anfangswerte zugewiesen werden.

# 4) Verwenden der Doppelklammerinitialisierung

Die Technik „Doppelklammerinitialisierung“ schafft eine innere Klasse. Diese Klasse ist anonym und enthält einen Instanzinitialisierer. Dies ist keine bevorzugte Technik und sollte vermieden werden, da dies zu Speicherlecks oder Serialisierungsproblemen führen kann.

Das folgende Programm zeigt die verschiedenen Methoden zum Initialisieren einer Karte, die oben erläutert wurden.

import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //using Collections //create an empty map Map emptymap = Collections.EMPTY_MAP; //create unmodifiable map using Collections Map unmodifiableMap = Collections.unmodifiableMap(emptymap); System.out.println('unmodifiableMap map values:' + unmodifiableMap); //singleton map Map singleton_map = Collections.singletonMap(10, ' TEN'); System.out.println('

singleton_map Map values:' + singleton_map); //using Java 8 //1. toMap method of collectors class Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('

map_cities values: ' + map_cities); //2. collectingAndThen method Map capitals_Map = Stream.of(new String()(){ {'MAH', 'Mumbai'}, {'GOA', 'Panaji'}, {'KAR', 'Bangaluru'} }).collect(Collectors.collectingAndThen (Collectors.toMap(p -> p(0), p -> p(1)), Collections::unmodifiableMap)); System.out.println('

capitals_Map values: ' + capitals_Map); //double brace initialization Map country_map = new HashMap(); country_map.put('USA', 'Washington'); country_map.put('UK', 'London'); country_map.put('IND', 'Delhi'); country_map.put('GER', 'Berlin'); System.out.println('

Map values:' + country_map); } }

Ausgabe:

unmodifizierbare Kartenzuordnungswerte: {}
singleton_map Map-Werte: {10 = TEN}
map_cities-Werte: {CH = Chennai, DL = New Delhi, MH = Mumbai}
capitals_Map-Werte: {MAH = Mumbai, GOA = Panaji, KAR = Bangaluru}
Kartenwerte: {USA = Washington, GER = Berlin, UK = London, IND = Delhi}

Karte initialisieren

Iterieren Sie über die Karte in Java und drucken Sie die Karte

Wir können die Karte genauso durchlaufen, wie wir die anderen Sammlungen durchlaufen haben. Zusätzlich zum Durchlaufen von Karteneinträgen können wir auch nur die Schlüssel oder nur die Werte in der Karte durchlaufen. Beachten Sie, dass zum Durchlaufen einer Karte diese konvertiert werden muss, um sie zuerst festzulegen.

Die folgenden Methoden werden verwendet, um die Karteneinträge zu durchlaufen.

Entry Iterator verwenden

Bei dieser Methode erhalten wir einen Eintragsiterator aus einem Eintragssatz. Anschließend rufen wir mit den Methoden getKey und getValue das Schlüssel-Wert-Paar für jeden Karteneintrag ab.

Das folgende Programm zeigt die Verwendung eines Eintragsiterators.

import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); //transform map to set Set entries = map_cities.entrySet(); //declare an iterator Iterator iterator = entries.iterator(); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate and print key and value pairs. while(iterator.hasNext()) { Map.Entry entry = iterator.next(); System.out.println('	' + entry.getKey() + '	' +entry.getValue()); } } }

Ausgabe:

Die Karteneinträge sind:
SCHLÜSSELWERT
CH Chennai
DL New Delhi
MH Mumbai

Eintragsiterator verwenden

Im obigen Programm erhalten wir mit der entrySet-Methode einen Eintragsiterator aus der Karte. Dann durchlaufen wir die Karte mit der Methode hasNext () des Eingabe-Iterators und drucken das Schlüssel-Wert-Paar.

Verwenden eines Eintrags für jede Schleife

Hier durchlaufen wir das entrySet mit for-each-Schleife und die Implementierung wird unten gezeigt.

import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate using for each over entry set and print key and value pairs. for(Map.Entry entry : map_cities.entrySet()){ System.out.println('	' + entry.getKey() + '	' +entry.getValue()); } } }

Ausgabe:

Die Karteneinträge sind:
SCHLÜSSELWERT
CH Chennai
DL New Delhi
MH Mumbai

Verwenden eines Eintrags für jede Schleife

Kartenmethoden

Die Kartenschnittstelle in Java unterstützt verschiedene Vorgänge, die denen anderer Sammlungen ähneln. In diesem Abschnitt werden die verschiedenen Methoden erläutert, die von der Map API in Java bereitgestellt werden. Da der Umfang dieses Tutorials auf die Einführung einer Kartenschnittstelle im Allgemeinen beschränkt ist, werden diese Methoden nicht beschrieben.

Wir werden diese Methoden im Detail diskutieren, während wir Kartenschnittstellenklassen diskutieren.

In der folgenden Tabelle sind alle von der Map-API bereitgestellten Methoden aufgeführt.

Methodenname	Methodenprototyp	Beschreibung
erhalten	V get (Objektschlüssel)	Gibt das Objekt oder den Wert für den angegebenen Schlüssel zurück
stellen	V put (Objektschlüssel, Objektwert)	Fügen Sie einen Schlüsselwerteintrag in die Karte ein
putAll	void putAll (Kartenkarte)	Fügen Sie die angegebenen Karteneinträge in die Karte ein. Mit anderen Worten, kopiert oder klont eine Karte.
Schlüsselsatz	Setze keySet ()	Gibt die festgelegte Ansicht der Karte zurück.
entrySet	einstellenentrySet ()	Rückgabe legt die Ansicht für eine bestimmte Karte fest
Werte	Sammlungswerte ()	Gibt die Sammlungsansicht der Werte in der Karte zurück.
Größe	int size ()	Gibt die Anzahl der Einträge in der Karte zurück
klar	void clear ()	Löscht die Karte
ist leer	boolean isEmpty ()	Überprüft, ob die Karte leer ist und gibt true zurück, wenn ja.
enthältWert	Boolescher Wert enthältWert (Objektwert)	Gibt true zurück, wenn die Map den Wert enthält, der dem angegebenen Wert entspricht
enthältKey	Boolescher Wert enthältKey (Objektschlüssel)	Gibt true zurück, wenn ein bestimmter Schlüssel in der Karte vorhanden ist
gleich	Boolescher Wert gleich (Objekt o)	Vergleicht das angegebene Objekt o mit der Karte
Hash-Code	int hashCode ()	Gibt den Hash-Code für die Map zurück
für jedes	void forEach (BiConsumer-Aktion)	Führt eine bestimmte Aktion für jeden Eintrag in der Karte aus
getOrDefault	V getOrDefault (Objektschlüssel, V defaultValue)	Gibt den angegebenen Wert für den angegebenen Schlüssel oder seinen Standardwert zurück, wenn der Schlüssel nicht vorhanden ist
entfernen	boolean remove (Objektschlüssel, Objektwert)	Entfernt angegebene Schlüssel und Werte
ersetzen	V ersetzen (K-Taste, V-Wert)	Ersetzt den angegebenen Schlüssel durch den angegebenen Wert
ersetzen	Boolescher Ersatz (K-Taste, V oldValue, V newValue)	Ersetzt den alten Wert durch einen neuen Wert für einen bestimmten Schlüssel
alles ersetzen	void replaceAll (BiFunction-Funktion)	Ruft die angegebene Funktion auf, um alle Karteneinträge zu ersetzen
putIfAbsent	V putIfAbsent (K-Taste, V-Wert)	Fügt den angegebenen Schlüsselwert nur ein, wenn er noch nicht vorhanden ist
berechnen	V-Berechnung (K-Taste, BiFunction remappingFunction)	Berechnet die Zuordnung für den angegebenen Schlüssel und Wert anhand der Zuordnungsfunktion.
computeIfAbsent	V computeIfAbsent (K-Taste, Function MappingFunction)	Berechnen Sie den Wert für den angegebenen Schlüssel mithilfe der Zuordnungsfunktion, falls nicht bereits vorhanden.
computeIfPresent	V computeIfPresent (K-Taste, BiFunction remappingFunction)	Berechnet die neue Zuordnung für den angegebenen Schlüssel mit der angegebenen Neuzuordnungsfunktion, wenn der Schlüsselwert bereits vorhanden ist
gehen	V merge (K-Taste, V-Wert, BiFunction remappingFunction)	Ordnet dem Wert einen bestimmten Schlüssel zu, wenn er nicht bereits oder dem Nullwert zugeordnet ist.

Alle oben genannten Methoden werden von der Kartenschnittstelle unterstützt. Beachten Sie, dass die Methoden, die schattiert erscheinen, die neuen Methoden sind, die in Java 8 enthalten waren.

Java Map-Implementierung

Das folgende Programm implementiert ein Kartenbeispiel in Java. Hier verwenden wir die meisten der oben diskutierten Methoden.

Das Beispiel zeigt verschiedene Get-Operationen, Put- und Set-Operationen.

import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class Main { public static void main(String() args) { //create a map Map country_map = new HashMap(); //assign values to the map country_map.put('IND', 'India'); country_map.put('SL', 'Srilanka'); country_map.put('CHN', 'China'); country_map.put('KOR', 'Korea'); country_map.put(null, 'Z'); // null key country_map.put('XX', null); // null value String value = country_map.get('CHN'); // get System.out.println('Key = CHN, Value : ' + value); value = country_map.getOrDefault('XX', 'Default Value'); //getOrDefault System.out.println('
Key = XX, Value : ' + value); boolean keyExists = country_map.containsKey(null); //containsKey boolean valueExists = country_map.containsValue('Z'); //containsValue System.out.println('
null keyExists : ' + keyExists + ', null valueExists= ' + valueExists); Set entrySet = country_map.entrySet(); //entrySet System.out.println('
entry set for the country_map: ' + entrySet); System.out.println('
Size of country_map : ' + country_map.size()); //size Map data_map = new HashMap(); data_map.putAll(country_map); //putAll System.out.println('
data_map mapped to country_map : ' + data_map); String nullKeyValue = data_map.remove(null); //remove System.out.println('
null key value for data_map : ' + nullKeyValue); System.out.println('
data_map after removing null key = ' + data_map); Set keySet = country_map.keySet(); //keySet System.out.println('
data map keys : ' + keySet); Collection values = country_map.values(); //values System.out.println('
data map values : ' + values); country_map.clear(); //clear System.out.println('
data map after clear operation, is empty :' + country_map.isEmpty()); } }

Ausgabe:

Schlüssel = CHN, Wert: China
Schlüssel = XX, Wert: null
null keyExists: true, null valueExists = true
Eintragssatz für die country_map: (null = Z, XX = null, CHN = China, SL = Srilanka, IND = Indien, KOR = Korea)
Größe der country_map: 6
Datenkarte, die der Länderkarte zugeordnet ist: {null = Z, XX = null, CHN = China, SL = Srilanka, IND = Indien, KOR = Kore
zu}
Nullschlüsselwert für data_map: Z.
data_map nach dem Entfernen des Nullschlüssels = {XX = null, CHN = China, SL = Srilanka, IND = Indien, KOR = Korea}
Datenzuordnungsschlüssel: (null, XX, CHN, SL, IND, KOR)
Datenkartenwerte: (Z, null, China, Srilanka, Indien, Korea)
Datenkarte nach Löschvorgang ist leer: true

Operationen abrufen, Operationen setzen und setzen

Sortieren einer Karte in Java

Da eine Karte aus Schlüssel-Wert-Paaren besteht, können wir die Karte nach Schlüsseln oder Werten sortieren.

In diesem Abschnitt sortieren wir eine Karte nach Schlüsseln und Werten.

Nach Schlüssel sortieren

Um eine Karte nach Schlüsseln zu sortieren, können wir eine Baumkarte verwenden. Die Baumkarte sortiert die Schlüssel automatisch. Das folgende Java-Programm konvertiert eine Karte in eine Baumkarte und zeigt die sortierten Schlüssel an.

import java.util.HashMap; import java.util.Map; import java.util.TreeMap; public class Main { public static void main(String() args) { //declare and initialize a map Map country_map = new HashMap(); country_map.put('I', 'India'); country_map.put('C', 'China'); country_map.put('A', 'America'); country_map.put('D', 'Denmark'); country_map.put('X', 'Hongkong'); //print original map System.out.println('Original Unsorted Map: '); display_map(country_map); System.out.println('
Map sorted by Key: '); //convert map to treemap and display it in which keys are auto sorted Map treecountry = new TreeMap(country_map); display_map(treecountry); } public static void display_map(Map map) { //obtain entry iterator and display key value pairs of map for (Map.Entry entry : map.entrySet()) { System.out.println('	' + entry.getKey() + '		' + entry.getValue()); } } }

Ausgabe:

Ursprüngliche unsortierte Karte:
Ein Amerika
C China
D Dänemark
X Hongkong
Ich Indien
Karte sortiert nach Schlüssel:
Ein Amerika
C China
D Dänemark
Ich Indien
X Hongkong

Nach Schlüssel sortieren

Das obige Programm erstellt eine Karte, die aus einem einzelnen Alphabetcode als Schlüssel und Ländernamen als Werten besteht. Zuerst zeigen wir die ursprüngliche Karte an, die nicht sortiert ist. Dann konvertieren wir die Karte in eine Baumkarte, die die Schlüssel automatisch sortiert. Schließlich zeigen wir die sortierte Baumkarte auf den Schlüsseln an.

Nach Wert sortieren

Um eine Karte nach Werten zu sortieren, konvertieren wir zuerst die Karte in eine Liste. Anschließend sortieren wir diese Liste mithilfe der Collections.sort () -Methode, bei der die Werte mithilfe eines Komparators verglichen und in einer bestimmten Reihenfolge angeordnet werden.

Sobald die Liste sortiert ist, werden die verknüpften Listeneinträge erneut in die Karte kopiert, wodurch wir die sortierte Karte erhalten.

Das folgende Java-Programm demonstriert das Sortieren einer Karte nach Wert. Das Programm verwendet LinkedHashMap, das an die Sortierfunktion weitergegeben wird. In der Sortierfunktion wird es in eine verknüpfte Liste konvertiert und sortiert. Nach dem Sortieren wird es wieder in LinkedHashMap konvertiert.

easy mp3 downloader kostenloser Download Vollversion

import java.util.*; public class Main { public static void main(String() args) { //define and initialize a map LinkedHashMap capitals_map = new LinkedHashMap(); capitals_map.put('NEP', 'Kathmandu'); capitals_map.put('IND', 'New Delhi'); capitals_map.put('USA', 'Washington'); capitals_map.put('UK', 'London'); capitals_map.put('AUS', 'Canberra'); //print original map System.out.println('Original unsorted map: '); System.out.println(capitals_map); //call sortMap method Map sorted_Map = sortMap(capitals_map); //print the sorted map System.out.println('
Map sorted on value : '); System.out.println('	Key	Value '); for (Map.Entry entry : sorted_Map.entrySet()) { System.out.println('	' + entry.getKey()+ '	' + entry.getValue()); } } public static LinkedHashMap sortMap(LinkedHashMap linked_map) { //create a linkedlist from LinkedHashMap List capital_List = new LinkedList(linked_map.entrySet()); //sort the LinkedList Collections.sort(capital_List, (o1, o2) -> o1.getValue().compareTo(o2.getValue())); //Create LinkedHashMap from linkedlist and return it LinkedHashMap finalMap = new LinkedHashMap(); for (Map.Entry entry : capital_List) { finalMap.put(entry.getKey(), entry.getValue()); } return finalMap; } }

Ausgabe:

Ursprüngliche unsortierte Karte:
{NEP=Kathmandu, IND=New Delhi, USA=Washington, UK=London, AUS=Canberra

Karte sortiert nach Wert:
Schlüsselwert
AUS Canberra
NEP Kathmandu
Großbritannien London
IND New Delhi
USA Washington

Nach Wert sortieren

Gleichzeitige Karte in Java

Eine concurrentMap ist eine Schnittstelle, die von der Schnittstelle java.util.map erbt. Die concurrentMap-Schnittstelle wurde erstmals in JDK 1.5 eingeführt und bietet eine Karte für den gleichzeitigen Zugriff.

Die concurrentMap-Schnittstelle ist Teil des Pakets java.util.concurrent.

Das folgende Java-Programm demonstriert die concurrentMap in Java.

import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } } import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } }

Ausgabe:

Erste gleichzeitige Karte: {100 = Rot, 101 = Grün, 102 = Blau}
Nach dem Hinzufügen des fehlenden Schlüssels 103: {100 = Rot, 101 = Grün, 102 = Blau, 103 = Lila}
Gleichzeitige Karte nach dem Entfernen von 101: {100 = Rot, 102 = Blau, 103 = Lila}
Fügen Sie den fehlenden Schlüssel 101 hinzu: {100 = Rot, 101 = Braun, 102 = Blau, 103 = Lila}
Ersetzen Sie den Wert bei Taste 101: {100 = Rot, 101 = Grün, 102 = Blau, 103 = Lila}

Gleichzeitige Karte in Java

Synchronisierte Karte in Java

Eine synchronisierte Karte ist eine Karte, die threadsicher ist und von einer bestimmten Karte unterstützt wird. In Java wird die synchronisierte Zuordnung mithilfe der synchronizedMap () -Methode der Klasse java.util.Collections abgerufen. Diese Methode gibt eine synchronisierte Karte für eine bestimmte Karte zurück.

Diese zurückgegebene synchronisierte Karte wird verwendet, um auf die Hintergrundkarte zuzugreifen und einen seriellen Zugriff zu erzielen.

Die allgemeine Deklaration der synchronizedMap () -Methode lautet:

public static Map synchronizedMap(Map m)

Dabei ist m => die gesicherte Karte.

Wie bereits erwähnt, gibt diese Methode die synchronisierte Ansicht der Karte m zurück.

Das folgende Java-Programm ist ein Beispiel für eine synchronisierte Karte.

import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a map Map int_map = new HashMap(); int_map.put(1, 10); int_map.put(2, 20); int_map.put(3, 30); int_map.put(4, 40); int_map.put(5, 50); //print the map System.out.println('Original (backed) Map: ' + int_map); //obtain synchronized map Map sync_map = Collections.synchronizedMap(int_map); //remove an element from the map int_map.remove(3, 30); //print the altered map System.out.println('
Synchronized map after remove(3, 30):' + sync_map); } }

Ausgabe:

Ursprüngliche (hinterlegte) Karte: {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Synchronisierte Karte nach dem Entfernen (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}

Synchronisierte Karte in Java

Statische Karte in Java

Eine statische Karte in Java ist eine Karte, die genau wie eine statische Variable als statisch deklariert wird. Wenn Sie eine Map als statisch deklarieren, wird sie zu einer zugänglichen Klassenvariablen, ohne das Objekt zu verwenden.

Es gibt zwei Ansätze zum Erstellen und Initialisieren einer statischen Karte in Java.

# 1) Verwenden einer statischen Variablen

Hier erstellen wir eine statische Map-Variable und instanziieren sie zusammen mit der Deklaration.

Dieser Ansatz wird im folgenden Java-Programm demonstriert.

import java.util.*; class Main { //declare a static map variable and initialize it with declaration private static final Map myMap = new HashMap(){ { put(1, 'India'); put(2, 'Portugal'); put(3, 'Germany'); } }; public static void main(String() args) { //print the map System.out.println('Static map using static map variable:'); System.out.println(myMap); } }

Ausgabe:

Statische Karte mit statischer Kartenvariable:
{1 = Indien, 2 = Portugal, 3 = Deutschland}

Statischen Block verwenden

# 2) Verwenden des statischen Blocks

In diesem Fall erstellen wir eine statische Kartenvariable. Dann erstellen wir einen statischen Block und initialisieren innerhalb dieses statischen Blocks die Map-Variable.

Das folgende Programm zeigt dies.

import java.util.*; class Main { // Declare the static map private static Map map; // declare a static block and initialize static map static { map = new HashMap(); map.put(1, 'Red'); map.put(2, 'Green'); map.put(3, 'Blue'); } public static void main(String() args) { System.out.println('Static Map using static block:'); System.out.println(map); } }

Ausgabe:

Statische Karte mit statischem Block:
{1 = Rot, 2 = Grün, 3 = Blau}

Statischen Block verwenden

Konvertierung der Liste in eine Karte

In diesem Abschnitt werden die Methoden zum Konvertieren der Liste in eine Karte erläutert.

Die zwei Methoden umfassen:

Traditionelle Methode

Bei der herkömmlichen Methode wird jedes Listenelement mithilfe einer for-each-Schleife in die Zuordnung kopiert.

Diese Implementierung wird unten gezeigt:

import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a list List colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Brown'); colorsList.add('White'); System.out.println('The given list: ' + colorsList); //declare a map Map map = new HashMap(); //initial Id(key) int i=1; //assign each list element to the map for (String color : colorsList) { map.put(i, color); i++; } //print the map System.out.println('Map generated from List:' + map); } }

Ausgabe:

Die angegebene Liste: (Rot, Grün, Blau, Braun, Weiß)
Aus Liste generierte Karte: {1 = Rot, 2 = Grün, 3 = Blau, 4 = Braun, 5 = Weiß}

Traditionelle Methode

Zu ordnende Liste in Java 8

Wir können auch die Java 8-Methode Collectors.mapOf () verwenden, die die angegebene Liste in eine Map konvertiert.

Das folgende Programm zeigt dies.

import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.stream.Collectors; // class for list class Subject { //sub_id => map key private Integer sub_id; // sub_name => map value private String sub_name; // Subject constructor public Subject(Integer sub_id, String sub_name) { // initialize sub_id and sub_name this.sub_id = sub_id; this.sub_name = sub_name; } // return sub_id public Integer getSub_Id() { return sub_id; } // return sub_name public String getSub_Name() { return sub_name; } } public class Main { public static void main(String() args) { // create a list and add values to the list List sub_list = new ArrayList(); sub_list.add(new Subject(1, 'Abacus')); sub_list.add(new Subject(2, 'Maths')); sub_list.add(new Subject(3, 'Physics')); sub_list.add(new Subject(3, 'Chemistry')); //use Java 8 Collectors.toMap() method to create a map and assign list elements to it LinkedHashMap sub_map = sub_list.stream() .collect( Collectors.toMap(Subject::getSub_Id, Subject::getSub_Name,(x, y) -> x + ', ' + y, LinkedHashMap::new)); //print the map System.out.println('Map obtained from list : ' + sub_map); } }

Ausgabe:

Karte aus Liste erhalten: {1 = Abakus, 2 = Mathematik, 3 = Physik, Chemie}

Liste zu Map in Java 8

In diesem Programm haben wir eine Klasse Subject, die als Listenklasse fungiert. Die Klasse Subject hat zwei Felder, d. H. Sub_id und sub_name. Wir haben Methoden, um die Feldwerte aus der Klasse zu lesen. In der Hauptfunktion erstellen wir Objekte dieser Klasse und erstellen eine Liste.

Diese Liste wird dann mithilfe der Collectors.MapOf-Methode, die die Elemente einzeln verwendet, in die Karte konvertiert. Es wird auch die sub_Id als Schlüssel für die Karte verwendet. Schließlich wird die Map generiert, die sub_Id als Schlüssel und Sub_Name als Wert hat.

Konvertieren Sie Map in String in Java

Eine Kartensammlung kann auf zwei Arten in eine Zeichenfolge konvertiert werden:

Verwenden von StringBuilder

Hier erstellen wir ein StringBuilder-Objekt und kopieren dann die Schlüssel-Wert-Paare der Map in das StringBuilder-Objekt. Dann konvertieren wir das StringBuilder-Objekt in einen String.

Das folgende Programm zeigt den Java-Code zum Konvertieren der Map in die Zeichenfolge.

import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); //create a StringBuilder object to store string StringBuilder map_String = new StringBuilder('{'); //append key-value pair of map to StringBuilder object for (Integer key : numberNames.keySet()) { map_String.append(key + '=' + numberNames.get(key) + ', '); } map_String.delete(map_String.length()-2, map_String.length()).append('}'); //print the string from StringBuilder System.out.println('
The string representation of map:'); System.out.println(map_String.toString()); } }

Ausgabe:

Die angegebene Karte: {20 = 20, 40 = 40, 10 = 10, 30 = 30}
Die Zeichenfolgendarstellung der Karte:
{20 = Zwanzig, 40 = Vierzig, 10 = Zehn, 30 = Dreißig}

Verwenden von StringBuilder

wie man ein Stoßwellenblitzobjekt öffnet

Verwenden von Java 8-Streams

Bei dieser Methode erstellen wir einen Stream aus den Map-Schlüsseln und konvertieren ihn dann in die Zeichenfolge.

Das unten angegebene Programm zeigt die Konvertierung der Karte in eine Zeichenfolge mithilfe von Streams.

import java.util.*; import java.util.stream.Collectors; public class Main{ public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); String map_String = numberNames.keySet().stream() .map(key -> key + '=' + numberNames.get(key)) .collect(Collectors.joining(', ', '{', '}')); //print the string System.out.println('
The string representation of map:'); System.out.println(map_String); } }

Ausgabe:

Die angegebene Karte: {20 = 20, 40 = 40, 10 = 10, 30 = 30}
Die Zeichenfolgendarstellung der Karte:
{20 = Zwanzig, 40 = Vierzig, 10 = Zehn, 30 = Dreißig}

Verwenden von Java 8-Streams

Konvertieren Sie die Karte in eine Liste in Java

Eine Karte besteht aus Schlüsseln und Werten, während eine Liste eine Folge einzelner Elemente ist. Beim Konvertieren der Karte in eine Liste konvertieren wir normalerweise Schlüssel in eine Liste von Schlüsseln und Werte in eine Liste von Werten.

Das folgende Java-Programm zeigt diese Konvertierung.

import java.util.*; public class Main { public static void main(String() args) { //declare a map and initialize it Map color_map = new HashMap(); color_map.put(10, 'red'); color_map.put(20, 'green'); color_map.put(30, 'blue'); color_map.put(40, 'cyan'); color_map.put(50, 'magenta'); //print the list of keys using map.keySet() method System.out.println('List of keys from the given map:'); List key_list = new ArrayList(color_map.keySet()); System.out.println(key_list); //print the list of values using map.values() method System.out.println('
List of values from the given map:'); List val_list = new ArrayList(color_map.values()); System.out.println(val_list); } }

Ausgabe:

Liste der Schlüssel aus der angegebenen Karte:
(50, 20, 40, 10, 30)
Liste der Werte aus der angegebenen Karte:
(Magenta, Grün, Cyan, Rot, Blau)

Konvertieren Sie die Karte in eine Liste in Java

Wörterbuch Vs. Karte in Java

Lassen Sie uns einige der Hauptunterschiede zwischen einem Wörterbuch und einer Karte in Java diskutieren.

Wörterbuch	Karte
Wörterbuch ist eine abstrakte Klasse.	Die Karte ist eine Schnittstelle.
Klassen und Methoden, die vom Framework für Wörterbuchklassen vor Sammlungen verwendet werden.	Von Kartenklassen verwendete Klassen und Methoden sind Teil des Sammlungsframeworks.
Wenn eine Klasse das Wörterbuch erweitert, kann sie keine andere Klasse erweitern, da Java nur eine einzelne Vererbung unterstützt	Die Karte ist eine Schnittstelle, sodass eine Klasse von der Karte und anderen Schnittstellen erben kann
Alte Implementierung. In neueren Java-Versionen fast veraltet.	Die Kartenschnittstelle hat die Wörterbuchimplementierung ersetzt.

Häufig gestellte Fragen

F # 1) Warum verwenden wir eine Kartenschnittstelle in Java?

Antworten: Die Map ist eine Schnittstelle in Java, die von Klassen implementiert wird, die Daten als Schlüssel-Wert-Paare speichern. Die Kartenschnittstelle bietet Operationen / Methoden, die für Schlüssel-Wert-Paare wie Einfügen, Aktualisieren, Löschen usw. ausgeführt werden können.

Q # 2)Was bedeutet MAP in Java?

Antworten: Eine Zuordnung in Java stellt eine Zuordnung eines Schlüssels mit einem bestimmten Wert dar. Eine Java-Karte speichert diese Schlüssel-Wert-Paare in einer Karte. Wir können den mit einem Schlüssel verknüpften Wert nachschlagen und abrufen, indem wir einfach den Schlüssel in der Karte verwenden.

Eine Map wird in Java mithilfe einer Schnittstelle implementiert, die nicht Teil der Collection-Schnittstelle ist. Aber die Karte ist eine Sammlung.

Q # 3)Was bekommt MAP?

Antworten: Get () ist eine Methode, die von einer Map-Schnittstelle in Java bereitgestellt wird und zum Abrufen des Werts eines bestimmten Schlüssels verwendet wird, der als Argument für die get () -Methode bereitgestellt wird. Wenn der Wert nicht vorhanden ist, wird eine Null zurückgegeben.

Q # 4)Ist die Karte eine Sammlung?

Antworten: Obwohl die Karte im Allgemeinen als Sammlung angesehen wird, wird keine Sammlungsschnittstelle implementiert. Einige Implementierungen von Map, wie z. B. Treemap, unterstützen keine Nullwerte oder Schlüssel.

Q # 5)Was ist der Unterschied zwischen Set und Map?

Antworten: Set ist nur eine Sammlung von Schlüsseln, während die Karte eine Sammlung von Schlüssel-Wert-Paaren ist. Während die Menge keine Nullwerte zulässt, erlauben einige der Kartenimplementierungen Nullwerte.

Set erlaubt keine doppelten Schlüssel. Die Karte kann doppelte Werte zulassen, die Schlüssel müssen jedoch eindeutig sein. Set wird normalerweise verwendet, wenn eine Sammlung eindeutiger Elemente gespeichert werden soll. Die Karte kann verwendet werden, wenn Daten in Form von Schlüssel-Wert-Paaren gespeichert werden müssen.

Fazit

In diesem Tutorial haben wir die Grundlagen der Kartenschnittstelle erläutert. Wir haben auch die verschiedenen Methoden und alle anderen Details im Zusammenhang mit der Kartenschnittstelle in Java gesehen. Wir haben erfahren, dass es verschiedene Implementierungen von Kartenschnittstellen gibt, einschließlich Treemap, Hashmap usw.

In unseren kommenden Tutorials werden wir diese Kartenimplementierung genauer diskutieren.

=> Besuchen Sie hier, um Java von Grund auf neu zu lernen.

Java Map Interface Tutorial mit Implementierung und Beispielen

Karten in Java

Erstellen Sie eine Karte in Java

Initialisieren Sie eine Karte in Java

# 1) Sammlungen verwenden

# 2) Verwenden von Java 8

# 3) Verwenden der put-Methode der Kartenschnittstelle

# 4) Verwenden der Doppelklammerinitialisierung

Iterieren Sie über die Karte in Java und drucken Sie die Karte

Entry Iterator verwenden

Verwenden eines Eintrags für jede Schleife

Kartenmethoden

Java Map-Implementierung

Sortieren einer Karte in Java

Nach Schlüssel sortieren

Nach Wert sortieren

Gleichzeitige Karte in Java

Synchronisierte Karte in Java

Statische Karte in Java

# 1) Verwenden einer statischen Variablen

# 2) Verwenden des statischen Blocks

Konvertierung der Liste in eine Karte

Traditionelle Methode

Zu ordnende Liste in Java 8

Konvertieren Sie Map in String in Java

Verwenden von StringBuilder

Verwenden von Java 8-Streams

Konvertieren Sie die Karte in eine Liste in Java

Wörterbuch Vs. Karte in Java

Häufig gestellte Fragen

Fazit

Literatur-Empfehlungen