TOC

Eine HashMap in Java initialisieren

Initialisieren Sie eine HashMap in Java

1. Überblick

In diesem Tutorial lernen wir verschiedene Möglichkeiten kennen, wie Sie einHashMap in Java initialisieren können.

Wir werden sowohl Java 8 als auch Java 9 verwenden.

Weitere Lektüre:

Zwei HashMaps in Java vergleichen

Erfahren Sie, wie Sie zwei HashMaps in Java vergleichen und die Unterschiede zwischen ihnen feststellen

Read more →

Arbeiten mit Karten mithilfe von Streams

Erfahren Sie, wie Sie Java Maps und Streams kombinieren

Read more →

2. Der statische Initialisierer für statischeHashMap

Wir können einHashMap initialisieren, das einenstatic Codeblock enthält: 

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. Einträge können bei Bedarf hinzugefügt und entfernt werden.

Lassen Sie es uns 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 Map auch mit der doppelten Klammersyntax initialisieren: 

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

Beachten Sie, dasswe must try to avoid this initialization technique as it creates an anonymous extra class at every usage, and also holds hidden references to the enclosing object und Probleme mit Speicherverlusten verursachen können.

3. Verwenden von Java-Sammlungen

Wenn wir eine singleton-unveränderliche Karte mit einem einzigen Eintrag erstellen müssen, wirdCollections.singletonMap() ehr 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, werdenjava.lang.UnsupportedOperationException. ausgegeben

Wir können auch eine unveränderliche leere Karte erstellen, indem wirCollections.emptyMap(): verwenden 

Map emptyMap = Collections.emptyMap();

4. Der Java 8 Weg

In diesem Abschnitt sehen wir uns an, wie Sie eine Karte mit Java 8Stream API. initialisieren können

4.1. Verwenden vonCollectors.toMap()

Verwenden wir einStream eines zweidimensionalenString-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 vonMap gleich sind.

Um es allgemeiner zu gestalten, nehmen wir das ArrayObjects and 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]));

Hier erstellen wir eine Karte des Schlüssels alsString und des Werts alsInteger.

4.2. Verwenden eines Streams vonMap.Entry

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

Verwenden wir zunächst dieSimpleEntry -Vereinfachung derEntry -Sinterschnittstelle: 

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 mitSimpleImmutableEntry Vereinfachung: 

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 Map

In bestimmten Anwendungsfällen müssen wir eine unveränderliche Karte initialisieren. Dies könnte erreicht werden, indemCollectors.toMap() inCollectors.collectingAndThen() eingeschlossen werden: 

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 die Verwendung einer solchen Initialisierung mitStreams, as 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 derMap-Schnittstelle, die die Erstellung und Initialisierung unveränderlicher Karten vereinfachen.

Schauen wir uns diese Factory-Methoden an.

5.1. Map.of()

Diese Factory-Methode akzeptiert kein Argument, ein einzelnes Argument und variable 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 demMap.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 zuUnsupportedOperationException. 

Außerdem lassen sie keine Nullschlüssel sowie doppelte Schlüssel zu.

Wenn wir nach der Initialisierung eine veränderbare oder wachsende Karte benötigen, können wir eine der Implementierungen der SchnittstelleMap erstellen und diese unveränderlichen Karten im Konstruktor übergeben: 

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. Mit Guave

Nachdem wir uns nun mit der Verwendung von Java befasst haben, können Sie eine Karte mit Apache Guava initialisieren: 

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

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

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

Die MethodeImmutableMap.of() etzt var-args in der Form key1, value1, key2, value2 usw. ab: 

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

7. Fazit

In diesem Artikel haben wir die verschiedenen Möglichkeiten zum Initialisieren vonMap durchlaufen, insbesondere um leere, singleton, unveränderliche und veränderbare Karten zu erstellen. As you can see, there’s a huge improvement in this field since Java 9.

Wie immer befindet sich der Beispielquellcode inGithub project. Die Java 9-Beispiele befinden sich inhere und in der Guava-Stichprobehere.

Related