Java HashMap: Daten smart als Key-Value-Paare or­ga­ni­sie­ren

Mit der Java-HashMap-Klasse spei­cherst du Daten ganz einfach in Schlüssel-Wert-Paaren. Das macht nicht nur die Ver­wal­tung deiner Listen bequemer, sondern eröffnet dir auch viele Mög­lich­kei­ten beim Da­ten­zu­griff. Wir zeigen dir die wich­tigs­ten Methoden im Überblick.

Was sind HashMaps in Java?

Es gibt ver­schie­de­ne Wege, Daten zu sichern und wieder abzurufen. Je nach Vorhaben eignet sich eine bestimmte Methode besser als andere. Oft ist die Java HashMap Class dabei die ideale Wahl. Im Gegensatz zu anderen Ansätzen speichert diese Klasse In­for­ma­tio­nen als Schlüssel-Wert-Paare. Das Prinzip: Jedem Schlüssel (Key) ist exakt ein Wert (Value) zu­ge­ord­net. Willst du einen Wert abrufen, nutzt du den passenden Schlüssel und erhältst sofort das richtige Ergebnis. Dabei können Schlüssel und Werte aus völlig un­ter­schied­li­chen Da­ten­ty­pen wie Strings, Zahlen oder Objekten bestehen.

Die Java-HashMap-Klasse bringt dir gleich mehrere Vorteile. Sie er­mög­licht dir eine per­for­man­te Suche innerhalb der Pro­gram­mier­spra­che. Zudem ver­hin­dert das Schlüssel-Wert-Prinzip, dass ein Key mehrfach vergeben wird – Dubletten sind also aus­ge­schlos­sen. Lediglich Objekte selbst können mit ver­schie­de­nen Schlüs­seln mehrfach vorkommen. Auch in Sachen Per­for­mance punktet diese Methode gegenüber starren Listen, da sie deutlich flexibler ist. Das ist auch ein Pluspunkt von Key-Value-Stores, die auf derselben Logik basieren. In den nächsten Ab­schnit­ten erfährst du, wie du Java HashMaps erstellst und für deine Projekte nutzt.

Wie werden sie erstellt?

Bevor du eine neue HashMap in Java anlegen kannst, musst du die Klasse im­por­tie­ren. Nutze dafür den Java-Befehl import. Danach kannst du die Map wie folgt erstellen:

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

Die beiden Da­ten­ty­pen, die hier durch ein Komma getrennt sind (in diesem Fall String, String), de­fi­nie­ren den Schlüssel und den Wert.

Neue HashMap in Java erzeugen

Schauen wir uns das Ganze an einem prak­ti­schen Beispiel an: Eine Kun­den­lis­te für ein Un­ter­neh­men. Diese Liste enthält den Namen der Kund­schaft sowie eine ein­deu­ti­ge Kun­den­num­mer. Während die Kun­den­num­mer (unser Schlüssel) einmalig ist, könnten theo­re­tisch mehrere Personen denselben Namen tragen – diese bekämen dann einfach eine eigene Nummer. Die Nummer speichern wir als Datentyp Integer, die Namen als Strings. So sieht die 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

Aktuell ist unsere Java HashMap noch leer. Um neue Schlüssel-Wert-Paare ein­zu­tra­gen, verwenden wir die Methode put(). In unserem Beispiel sieht das 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");
	System.out.println(kundenliste);
	}
}

Mit dem Befehl System.out.println lassen wir uns die Liste anzeigen. Die Ausgabe sieht dann so aus:

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

Auf Elemente zugreifen

Die Kun­den­lis­te steht, doch wie greifen wir nun auf einzelne Einträge zu? Dafür übergeben wir den Schlüssel an die Methode get(). Hier ein Beispiel:

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));
	}
}

Als Ergebnis wird uns nun der Name „Sabine Schulz“ aus­ge­ge­ben.

Einzelne oder alle Einträge entfernen

Möchtest du einen spe­zi­fi­schen Eintrag löschen, nutzt du die Methode remove(). Das funk­tio­niert in der Praxis so:

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 aktuelle Liste sieht danach so aus:

{15312=Peter Smith, 73329=Maria Grosso}

Du kannst auch die komplette Liste auf einmal leeren. Dafür gibt es die Methode clear(). An­ge­wen­det auf unser Beispiel:

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);
	}
}

Die Ausgabe bleibt in diesem Fall leer:

{ }

Anzahl der Einträge ermitteln

Auch wenn unser Beispiel klein ist, kannst du mit dieser Klasse riesige Da­ten­men­gen verwalten. Um her­aus­zu­fin­den, wie viele Einträge – also wie viele Kund:innen – sich in deiner Map befinden, nutzt du size(). Die Anwendung ist simpel:

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());
	}
}

In unserem Fall erhalten wir als Ergebnis die Zahl 3.

Schlüssel oder Werte einzeln dar­stel­len

Manchmal benötigst du nur eine Liste aller Schlüssel oder aller Werte. Das lässt sich über eine for-each-Schleife lösen. Mit der Methode keySet() sprichst du die Schlüssel an, mit values() die Werte. Letzteres sieht 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);
		}
	}
}

Das Ergebnis der Abfrage:

Sabine Schulz
Peter Smith
Maria Grosso

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

Du kannst nicht nur Daten abrufen, sondern auch checken, ob ein be­stimm­tes Element überhaupt existiert. Dafür nutzt du con­ta­ins­Key() für Schlüssel oder con­ta­insVa­lue() für Werte. Ist der gesuchte Inhalt vorhanden, gibt Java „true“ aus, ansonsten „false“. So setzt du beide Methoden ein:

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 die Nummer „15312“ existiert, der Name „Stuart Miller“ aber nicht, sieht die Ausgabe so aus:

true
false