Java HashMap: Daten in Schlüssel-Wert-Paaren speichern

Mit der Java-HashMaps-Klasse speichern Sie Daten in Schlüssel-Wert-Paaren. Das er­leich­tert nicht nur den Abruf und die Pflege Ihrer Liste, sondern bietet Ihnen auch zahl­rei­che Zu­griffs­mög­lich­kei­ten. Wir stellen Ihnen die wich­tigs­ten Methoden vor.

Was sind HashMaps in Java?

Es gibt ver­schie­de­ne Methoden, wie Sie Daten speichern und wieder abrufen können. Je nach Ein­satz­zweck mag sich die eine oder andere Art der Spei­che­rung besser eignen. In vielen Fällen dürfte die Java HashMap Class die beste Lösung sein. Im Gegensatz zu anderen Methoden speichert diese Klasse Daten als Schlüssel-Wert-Paare. Dieses Konzept sieht vor, dass jedem Schlüssel (Key) genau ein Wert (Value) zu­ge­wie­sen ist. Wenn Sie nun diesen Wert abrufen möchten, können Sie dafür den zu­ge­hö­ri­gen Schlüssel verwenden und werden immer das gesuchte Ergebnis erhalten. Schlüssel und Werte dürfen dabei aus ganz un­ter­schied­li­chen Da­ten­ty­pen wie Strings, Zahlen oder anderen Objekte bestehen.

Die Java-HashMap-Klasse bietet dadurch gleich mehrere Vorteile. Sie erlaubt Ihnen zuerst eine schnelle und er­folg­rei­che Suche im Rahmen der Pro­gram­mier­spra­che. Gleich­zei­tig ver­hin­dert der Schlüssel-Wert-Ansatz, dass einem Schlüssel mehrere Werte zu­ge­wie­sen werden. Dop­pe­lun­gen sind somit aus­ge­schlos­sen. Nur Objekte können auch mehrmals mit un­ter­schied­li­chen Schlüs­seln hin­zu­ge­fügt werden. Auch auf die Per­for­mance hat diese Art der Spei­che­rung und Suche positive Aus­wir­kun­gen gegenüber starren Listen, die deutlich weniger flexibel sind. Dies ist auch einer der großen Vorteile von Key-Value-Stores, die dasselbe Prinzip nutzen. In den folgenden Absätzen zeigen wir Ihnen daher, wie Sie Java HashMaps erstellen und für Ihre Zwecke nutzen.

Wie werden sie erstellt?

Um eine neue HashMap in Java zu erstellen, müssen Sie die Klasse zunächst im­por­tie­ren. Dafür nutzen Sie den Java-Befehl import. Danach können Sie die Map erzeugen. Das sieht so aus:

import java.util.HashMap;
HashMap<String, String> nameDerHashMap = new HashMap<String, String> ();

Bei den beiden Da­ten­ty­pen, die mit einem Komma von­ein­an­der getrennt werden (in diesem Fall String, String), handelt es sich um den Schlüssel und den Wert.

Neue HashMap in Java erzeugen

Um die Funk­ti­ons­wei­se besser ver­an­schau­li­chen zu können, wählen wir ein prak­ti­sches Beispiel. Dabei soll eine Kun­den­lis­te ge­spei­chert werden, die ein Un­ter­neh­men jederzeit abrufen kann. Diese besteht auf der einen Seite aus einem Namen der Kundin oder des Kunden und auf der anderen Seite aus einer Kun­den­num­mer. Während die Kun­den­num­mer (in unserem Beispiel der Schlüssel) immer ein­zig­ar­tig ist, kann es theo­re­tisch auch mehrere Kundinnen oder Kunden mit demselben Namen geben. Diese würden dann al­ler­dings wieder eine eigene Nummer erhalten. Diese Nummer wird als Datentyp Integer hin­ter­legt, die Namen als Strings. So sieht die ent­spre­chen­de HashMap in Java aus:

import java.util.HashMap;
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> kundenliste = new HashMap<>();
	}
}

Elemente hin­zu­fü­gen

Nun haben wir zwar die Java HashMap, diese ist al­ler­dings noch völlig leer. Um nun neuen Schlüssel-Wert-Paare hin­zu­zu­fü­gen, nutzen wir die Methode put(). In unserem Beispiel sieht das fol­gen­der­ma­ßen aus:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> kundenliste = new HashMap<>();
	kundenliste.put (1077, "Sabine Schulz");
	kundenliste.put (15312, "Peter Smith");
	kundenliste.put (73329, "Maria Grosso");
	System.out.println(kundenliste);
	}
}

Den Befehl System.out.println nutzen wir, um uns unsere Kun­den­lis­te anzeigen zu lassen. Die Ausgabe sollte nun so aussehen:

{1077=Sabine Schulz, 15312=Peter Smith, 73329=Maria Grosso}

Auf Elemente zugreifen

Jetzt haben wir zwar eine Kun­den­lis­te angelegt, die theo­re­tisch deutlich mehr Einträge umfassen kann, wollen aber auf die einzelnen Kundinnen und Kunden auch zugreifen können. Dafür übergeben wir den Schlüssel an die Methode get(). So sieht das bei­spiel­haft aus:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> kundenliste = new HashMap<>();
	kundenliste.put (1077, "Sabine Schulz");
	kundenliste.put (15312, "Peter Smith");
	kundenliste.put (73329, "Maria Grosso");
	System.out.println(kundenliste.get(1077));
	}
}

In unserer Ausgabe sollte dann lediglich der Name „Sabine Schulz“ er­schei­nen.

Einzelne oder alle Einträge entfernen

Wenn Sie einen be­stimm­ten Eintrag entfernen möchten, nutzen Sie die Methode remove(). Diese sieht in der Praxis so aus:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> kundenliste = new HashMap<>();
	kundenliste.put (1077, "Sabine Schulz");
	kundenliste.put (15312, "Peter Smith");
	kundenliste.put (73329, "Maria Grosso");
	kundenliste.remove(1077);
	System.out.println(kundenliste);
	}
}

Die Ausgabe sieht nun so aus:

{15312=Peter Smith, 73329=Maria Grosso}

Al­ter­na­tiv haben Sie die Mög­lich­keit, die gesamte Liste zu löschen. Dafür nutzen Sie die Methode clear(). So wenden wir sie auf unser Beispiel an:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> kundenliste = new HashMap<>();
	kundenliste.put (1077, "Sabine Schulz");
	kundenliste.put (15312, "Peter Smith");
	kundenliste.put (73329, "Maria Grosso");
	kundenliste.clear();
	System.out.println(kundenliste);
	}
}

Als Ausgabe erhalten wir dann lediglich dies:

{ }

Anzahl der Einträge ermitteln

Während unsere Java HashMap sehr über­sicht­lich ist, können Sie natürlich auch deutlich um­fang­rei­che­re Projekte mit dieser Klasse rea­li­sie­ren. In unserem Beispiel kann es von großem Interesse sein, die genaue Anzahl der un­ter­schied­li­chen Einträge zu ermitteln. Dies wäre schließ­lich Ihr gesamter Kun­den­stamm. Die passende Methode dafür ist size(). So wird sie an­ge­wen­det:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> kundenliste = new HashMap<>();
	kundenliste.put (1077, "Sabine Schulz");
	kundenliste.put (15312, "Peter Smith");
	kundenliste.put (73329, "Maria Grosso");
	System.out.println(kundenliste.size());
	}
}

Als Ausgabe erhalten wir dann in unserem über­schau­ba­ren Beispiel die Zahl 3.

Schlüssel oder Werte allein dar­stel­len

Es ist auch möglich, eine Auf­lis­tung zu erhalten, die lediglich die Schlüssel oder die Werte enthält. Die Basis dafür ist eine for-each-Loop. Für Schlüssel nutzen Sie die Methode keySet() und für Werte die Methode values(). Letztere sieht bei­spiels­wei­se so aus:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> kundenliste = new HashMap<>();
	kundenliste.put (1077, "Sabine Schulz");
	kundenliste.put (15312, "Peter Smith");
	kundenliste.put (73329, "Maria Grosso");
	for (String i : kundenliste.values()) {
		System.out.println(i);
		}
	}
}

Unsere Ausgabe ist dann diese:

Sabine Schulz
Peter Smith
Maria Grosso

Ver­füg­bar­keit eines Elements über­prü­fen

Es ist nicht nur möglich, auf einen be­stimm­ten Eintrag zu­zu­grei­fen, sondern auch zu erfragen, ob ein Element überhaupt in der Java HashMap enthalten ist. Dafür nutzen wir die Methoden con­ta­ins­Key() (für Schlüssel) und con­ta­insVa­lue() (für Werte). Ist das Element enthalten, erhalten wir die Ausgabe „true“. Wurde das Element nicht hin­ter­legt, lautet das Ergebnis „false“. So funk­tio­nie­ren beide Methoden in der Praxis:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> kundenliste = new HashMap<>();
	kundenliste.put (1077, "Sabine Schulz");
	kundenliste.put (15312, "Peter Smith");
	kundenliste.put (73329, "Maria Grosso");
	System.out.println(kundenliste.containsKey(15312));
	System.out.println(kundenliste.containsValue("Stuart Miller");
	}
}

Da der Schlüssel „15312“ enthalten ist, der Wert „Stuart Miller“ al­ler­dings nicht gelistet wurde, lautet die Ausgabe so:

true
false