Java HashMap: put, get, iterieren und gängige Muster

Eine Map speichert Schlüssel-Wert-Paare

Eine HashMap (aus java.util) speichert Zuordnungen: jeder Schlüssel wird auf einen Wert abgebildet, und du schlägst Werte über ihren Schlüssel in annähernd konstanter Zeit nach. Stell dir ein Wörterbuch vor: das Wort ist der Schlüssel, die Definition ist der Wert.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        System.out.println(ages.get("Boris"));
        System.out.println(ages);
    }
}

Die beiden Typparameter sind <KeyType, ValueType>. Hier sind die Schlüssel String und die Werte Integer. Wie bei ArrayList typisierst du die Variable üblicherweise als die Map-Schnittstelle und konstruierst eine HashMap.

put, get und Überschreiben

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);
        stock.put("apples", 75);   // gleicher Schlüssel -> überschreibt den alten Wert

        System.out.println(stock.get("apples"));  // 75
        System.out.println(stock.get("pears"));    // null - Schlüssel nicht vorhanden
    }
}

Zwei Dinge, die du verinnerlichen solltest:

• Ein Schlüssel ist eindeutig. put mit einem vorhandenen Schlüssel ersetzt dessen Wert und gibt den alten zurück.
• get auf einen fehlenden Schlüssel gibt null zurück, keinen Fehler. Das automatische Unboxing dieses null in ein int wirft eine NullPointerException, eine häufige Fehlerquelle.

getOrDefault umgeht die Null-Falle

Statt jedes Mal auf null zu prüfen, frag nach einem Standardwert:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);

        int apples = stock.getOrDefault("apples", 0);
        int pears = stock.getOrDefault("pears", 0);

        System.out.println(apples + " apples, " + pears + " pears");
    }
}

Das ist die sauberste Art, „vielleicht vorhandene" Abfragen zu behandeln, und führt direkt zum berühmtesten HashMap-Muster.

Vorkommen zählen

Zu zählen, wie oft jedes Element vorkommt, ist die Lehrbuchaufgabe für eine HashMap:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        String text = "the cat the dog the cat";
        Map<String, Integer> counts = new HashMap<>();

        for (String word : text.split(" ")) {
            counts.put(word, counts.getOrDefault(word, 0) + 1);
        }

        System.out.println(counts);
    }
}

Das Muster map.put(key, map.getOrDefault(key, 0) + 1) liest sich als „nimm den aktuellen Zähler (oder null), addiere eins und speichere ihn zurück". Ein sauberes Äquivalent ist counts.merge(word, 1, Integer::sum).

Prüfen und Entfernen

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        System.out.println(ages.containsKey("Ada"));     // true
        System.out.println(ages.containsValue(29));      // true
        System.out.println(ages.size());                 // 2

        ages.remove("Ada");
        System.out.println(ages.containsKey("Ada"));     // false
    }
}

putIfAbsent(key, value) schreibt nur, wenn der Schlüssel fehlt, nützlich für die verzögerte Initialisierung.

Über eine HashMap iterieren

Die häufigste Schleife durchläuft entrySet() und liefert dir jeden Schlüssel und Wert zusammen:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Wenn du nur die Schlüssel oder nur die Werte brauchst:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        for (String name : ages.keySet()) {
            System.out.println(name);
        }
        for (int age : ages.values()) {
            System.out.println(age);
        }
    }
}

Du kannst auch forEach mit einer Lambda verwenden: ages.forEach((name, age) -> System.out.println(name + ": " + age));.

Die HashMap behält die Reihenfolge nicht bei

Eine HashMap gibt keine Garantie über die Iterationsreihenfolge: sie ist das, was das Hashing erzeugt, und kann sich zwischen Durchläufen ändern. Wenn du eine vorhersehbare Reihenfolge brauchst:

• LinkedHashMap bewahrt die Einfügereihenfolge.
• TreeMap hält die Schlüssel nach natürlicher Ordnung sortiert (oder nach einem Comparator, den du angibst).

Alle drei implementieren die Map-Schnittstelle, sodass der Wechsel eine einzeilige Änderung am Konstruktor ist.

Schlüssel müssen hashbar sein

HashMap findet Einträge, indem sie den Schlüssel hasht, daher müssen hashCode() und equals() eines Schlüssels miteinander übereinstimmen. Eingebaute Typen wie String und Integer machen das bereits korrekt. Wenn du deine eigene Klasse als Schlüssel verwendest, überschreibe sowohl equals als auch hashCode, andernfalls landen zwei Objekte, die inhaltlich „gleich" sind, in unterschiedlichen Buckets, und deine Abfragen schlagen auf rätselhafte Weise fehl.

Als Nächstes: HashSet

Eine HashMap beantwortet „welcher Wert ist unter diesem Schlüssel gespeichert?". Wenn dich nur interessiert, ob etwas überhaupt vorhanden ist (eine Menge eindeutiger Werte, ohne zugehörige Daten), ist das Werkzeug HashSet, das als Nächstes kommt.