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

Mit der Java-HashMaps-Klasse speichern Sie Daten in Schlüssel-Wert-Paaren. Das erleichtert nicht nur den Abruf und die Pflege Ihrer Liste, sondern bietet Ihnen auch zahlreiche Zugriffsmöglichkeiten. Wir stellen Ihnen die wichtigsten Methoden vor.

Was sind HashMaps in Java?

Es gibt verschiedene Methoden, wie Sie Daten speichern und wieder abrufen können. Je nach Einsatzzweck mag sich die eine oder andere Art der Speicherung 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) zugewiesen ist. Wenn Sie nun diesen Wert abrufen möchten, können Sie dafür den zugehörigen Schlüssel verwenden und werden immer das gesuchte Ergebnis erhalten. Schlüssel und Werte dürfen dabei aus ganz unterschiedlichen Datentypen wie Strings, Zahlen oder anderen Objekte bestehen.

Die Java-HashMap-Klasse bietet dadurch gleich mehrere Vorteile. Sie erlaubt Ihnen zuerst eine schnelle und erfolgreiche Suche im Rahmen der Programmiersprache. Gleichzeitig verhindert der Schlüssel-Wert-Ansatz, dass einem Schlüssel mehrere Werte zugewiesen werden. Doppelungen sind somit ausgeschlossen. Nur Objekte können auch mehrmals mit unterschiedlichen Schlüsseln hinzugefügt werden. Auch auf die Performance hat diese Art der Speicherung und Suche positive Auswirkungen 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 importieren. 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 Datentypen, die mit einem Komma voneinander getrennt werden (in diesem Fall String, String), handelt es sich um den Schlüssel und den Wert.

Neue HashMap in Java erzeugen

Um die Funktionsweise besser veranschaulichen zu können, wählen wir ein praktisches Beispiel. Dabei soll eine Kundenliste gespeichert werden, die ein Unternehmen jederzeit abrufen kann. Diese besteht auf der einen Seite aus einem Namen der Kundin oder des Kunden und auf der anderen Seite aus einer Kundennummer. Während die Kundennummer (in unserem Beispiel der Schlüssel) immer einzigartig ist, kann es theoretisch auch mehrere Kundinnen oder Kunden mit demselben Namen geben. Diese würden dann allerdings wieder eine eigene Nummer erhalten. Diese Nummer wird als Datentyp Integer hinterlegt, die Namen als Strings. So sieht die entsprechende HashMap in Java aus:

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

Elemente hinzufügen

Nun haben wir zwar die Java HashMap, diese ist allerdings noch völlig leer. Um nun neuen Schlüssel-Wert-Paare hinzuzufügen, nutzen wir die Methode put(). In unserem Beispiel sieht das folgendermaß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 Kundenliste 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 Kundenliste angelegt, die theoretisch 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 beispielhaft 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“ erscheinen.

Einzelne oder alle Einträge entfernen

Wenn Sie einen bestimmten 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}

Alternativ haben Sie die Möglichkeit, 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 übersichtlich ist, können Sie natürlich auch deutlich umfangreichere Projekte mit dieser Klasse realisieren. In unserem Beispiel kann es von großem Interesse sein, die genaue Anzahl der unterschiedlichen Einträge zu ermitteln. Dies wäre schließlich Ihr gesamter Kundenstamm. Die passende Methode dafür ist size(). So wird sie angewendet:

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 überschaubaren Beispiel die Zahl 3.

Schlüssel oder Werte allein darstellen

Es ist auch möglich, eine Auflistung 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 beispielsweise 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

Verfügbarkeit eines Elements überprüfen

Es ist nicht nur möglich, auf einen bestimmten Eintrag zuzugreifen, sondern auch zu erfragen, ob ein Element überhaupt in der Java HashMap enthalten ist. Dafür nutzen wir die Methoden containsKey() (für Schlüssel) und containsValue() (für Werte). Ist das Element enthalten, erhalten wir die Ausgabe „true“. Wurde das Element nicht hinterlegt, lautet das Ergebnis „false“. So funktionieren 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“ allerdings nicht gelistet wurde, lautet die Ausgabe so:

true
false