Initialisieren Sie eine HashMap in Java

1. Übersicht

In diesem Tutorial lernen wir verschiedene Möglichkeiten kennen, eine HashMap in Java zu initialisieren .

Wir werden sowohl Java 8 als auch Java 9 verwenden.

2. Der statische Initialisierer für eine statische HashMap

Wir können eine HashMap mit einem statischen Codeblock initialisieren :

public static Map articleMapOne; static { articleMapOne = new HashMap(); articleMapOne.put("ar01", "Intro to Map"); articleMapOne.put("ar02", "Some article"); }

Der Vorteil dieser Art der Initialisierung besteht darin, dass die Karte veränderbar ist, jedoch nur für statische Zwecke funktioniert. Folglich können Einträge nach Bedarf hinzugefügt und entfernt werden.

Lassen Sie uns fortfahren und es testen:

@Test public void givenStaticMap_whenUpdated_thenCorrect() { MapInitializer.articleMapOne.put( "NewArticle1", "Convert array to List"); assertEquals( MapInitializer.articleMapOne.get("NewArticle1"), "Convert array to List"); }

Wir können die Karte auch mit der Doppelklammer-Syntax initialisieren:

Map doubleBraceMap = new HashMap() {{ put("key1", "value1"); put("key2", "value2"); }};

Beachten Sie, dass wir versuchen müssen, diese Initialisierungstechnik zu vermeiden, da sie bei jeder Verwendung eine anonyme zusätzliche Klasse erstellt, versteckte Verweise auf das einschließende Objekt enthält und möglicherweise Probleme mit Speicherverlusten verursacht.

3. Verwenden von Java-Sammlungen

Wenn wir eine unveränderliche Singleton-Map mit einem einzelnen Eintrag erstellen müssen, ist Collections.singletonMap () sehr nützlich:

public static Map createSingletonMap() { return Collections.singletonMap("username1", "password1"); }

Beachten Sie, dass die Karte hier unveränderlich ist. Wenn wir versuchen, weitere Einträge hinzuzufügen, wird java.lang.UnsupportedOperationException ausgelöst.

Mit Collections.emptyMap () können wir auch eine unveränderliche leere Karte erstellen :

Map emptyMap = Collections.emptyMap();

4. Der Java 8-Weg

In diesem Abschnitt untersuchen wir die Möglichkeiten zum Initialisieren einer Karte mithilfe der Java 8 Stream-API.

4.1. Verwenden von Collectors.toMap ()

Verwenden wir einen Stream eines zweidimensionalen String- Arrays und sammeln sie in einer Karte:

Map map = Stream.of(new String[][] { { "Hello", "World" }, { "John", "Doe" }, }).collect(Collectors.toMap(data -> data[0], data -> data[1]));

Beachten Sie hier, dass der Datentyp des Schlüssels und der Wert der Karte identisch sind.

Um es allgemeiner zu gestalten, nehmen wir das Array von Objekten und führen dieselbe Operation aus:

 Map map = Stream.of(new Object[][] { { "data1", 1 }, { "data2", 2 }, }).collect(Collectors.toMap(data -> (String) data[0], data -> (Integer) data[1]));

Als Ergebnis erstellen wir eine Zuordnung des Schlüssels als Zeichenfolge und des Werts als Ganzzahl .

4.2. Verwenden eines Streams von Map.Entry

Hier verwenden wir die Instanzen von Map.Entry. Dies ist ein weiterer Ansatz, bei dem wir unterschiedliche Schlüssel- und Werttypen haben.

Verwenden wir zunächst die SimpleEntry- Implementierung der Entry- Schnittstelle:

Map map = Stream.of( new AbstractMap.SimpleEntry("idea", 1), new AbstractMap.SimpleEntry("mobile", 2)) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Jetzt erstellen wir die Karte mit der SimpleImmutableEntry- Implementierung:

Map map = Stream.of( new AbstractMap.SimpleImmutableEntry("idea", 1), new AbstractMap.SimpleImmutableEntry("mobile", 2)) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

4.3. Initialisieren einer unveränderlichen Karte

In bestimmten Anwendungsfällen müssen wir eine unveränderliche Karte initialisieren. Dies kann durch Umschließen von Collectors.toMap () in Collectors.collectingAndThen () erfolgen :

Map map = Stream.of(new String[][] { { "Hello", "World" }, { "John", "Doe" }, }).collect(Collectors.collectingAndThen( Collectors.toMap(data -> data[0], data -> data[1]), Collections:: unmodifiableMap));

Beachten Sie, dass wir eine solche Initialisierung mit Streams vermeiden sollten , da dies einen enormen Leistungsaufwand verursachen kann und viele Müllobjekte nur zum Initialisieren der Karte erstellt werden.

5. Der Java 9-Weg

Java 9 verfügt über verschiedene Factory-Methoden in der Map- Oberfläche, die das Erstellen und Initialisieren unveränderlicher Maps vereinfachen.

Lassen Sie uns diese Fabrikmethoden untersuchen.

5.1. Karte von()

Diese Factory-Methode akzeptiert kein Argument, kein einzelnes Argument und keine variablen Argumente:

Map emptyMap = Map.of(); Map singletonMap = Map.of("key1", "value"); Map map = Map.of("key1","value1", "key2", "value2");

Beachten Sie, dass diese Methode nur maximal 10 Schlüssel-Wert-Paare unterstützt.

5.2. Map.ofEntries ()

Es ähnelt Map.of () , hat jedoch keine Einschränkungen hinsichtlich der Anzahl der Schlüssel-Wert-Paare:

Map map = Map.ofEntries( new AbstractMap.SimpleEntry("name", "John"), new AbstractMap.SimpleEntry("city", "budapest"), new AbstractMap.SimpleEntry("zip", "000000"), new AbstractMap.SimpleEntry("home", "1231231231") );

Beachten Sie, dass die Factory-Methoden unveränderliche Karten erzeugen. Daher führt jede Mutation zu einer UnsupportedOperationException.

Außerdem erlauben sie keine Nullschlüssel oder doppelten Schlüssel.

Wenn wir nun eine veränderbare oder wachsende Karte nach der Initialisierung benötigen, können wir eine der Implementierungen der erstellen Map - Schnittstelle und geben diese unveränderlichen Karten im Konstruktor:

Map map = new HashMap ( Map.of("key1","value1", "key2", "value2")); Map map2 = new HashMap ( Map.ofEntries( new AbstractMap.SimpleEntry("name", "John"), new AbstractMap.SimpleEntry("city", "budapest")));

6. Verwenden von Guave

Nachdem wir uns mit der Verwendung von Kern-Java befasst haben, gehen wir weiter und initialisieren eine Karte mithilfe der Guava-Bibliothek:

Map articles = ImmutableMap.of("Title", "My New Article", "Title2", "Second Article");

Dies würde eine unveränderliche Karte erstellen und eine veränderbare:

Map articles = Maps.newHashMap(ImmutableMap.of("Title", "My New Article", "Title2", "Second Article"));

Die Methode ImmutableMap.of () verfügt auch über überladene Versionen, die bis zu 5 Paare von Schlüsselwertparametern aufnehmen können. So würde ein Beispiel mit 2 Parameterpaaren aussehen:

ImmutableMap.of("key1", "value1", "key2", "value2");

7. Fazit

In diesem Artikel haben wir die verschiedenen Möglichkeiten zum Initialisieren einer Karte untersucht , insbesondere um leere, einzelne, unveränderliche und veränderbare Karten zu erstellen. Wie wir sehen können, gibt es in diesem Bereich seit Java 9 eine enorme Verbesserung.

Der Beispielquellcode befindet sich wie immer im Github-Projekt. Die Java 9-Beispiele finden Sie hier und das Guava-Beispiel hier.