LinkedHashMap

Kurz: Eine Map-Implementierung, die — anders als die reguläre HashMap — die Einfügereihenfolge (oder wahlweise Zugriffsreihenfolge) der Schlüssel beibehält.

Genauer: Intern kombiniert LinkedHashMap eine Hash-Tabelle für schnellen Zugriff mit einer verketteten Liste, die die Reihenfolge der Einträge nachhält. Mit dem Zugriffsreihenfolge-Modus (accessOrder = true) lässt sich damit z. B. simpel ein LRU-Cache (zuletzt genutzte Einträge zuletzt) bauen.

Im Detail

Map<String, Integer> normal = new HashMap<>();
Map<String, Integer> geordnet = new LinkedHashMap<>();
 
for (Map<String, Integer> map : List.of(normal, geordnet)) {
    map.put("Zebra", 1);
    map.put("Anna", 2);
    map.put("Mittel", 3);
}
 
System.out.println(normal);   // Reihenfolge NICHT garantiert, z.B. {Anna=2, Mittel=3, Zebra=1}
System.out.println(geordnet); // IMMER Einfügereihenfolge: {Zebra=1, Anna=2, Mittel=3}
 
// LRU-Cache mit fester Größe: ältester Eintrag fliegt automatisch raus
Map<String, Integer> lru = new LinkedHashMap<>(16, 0.75f, true) { // true = Zugriffsreihenfolge
    protected boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {
        return size() > 3; // maximal 3 Einträge behalten
    }
};

LinkedHashMap kostet gegenüber HashMap etwas mehr Speicher (für die zusätzliche verkettete Liste, die die Reihenfolge nachhält) und ist minimal langsamer beim Einfügen — der Zugriff per get() bleibt aber genauso schnell (O(1) im Schnitt), weil intern weiterhin dieselbe Hash-Tabelle für den eigentlichen Lookup genutzt wird. Die Kombination aus Zugriffsreihenfolge-Modus und überschriebenem removeEldestEntry() (wie im LRU-Beispiel) ist ein klassisches, kompaktes Muster, um einen einfachen Cache mit fester Kapazität zu bauen, ohne eine eigene Datenstruktur von Grund auf schreiben zu müssen.

Wann welche Map-Implementierung?

Java bietet drei gebräuchliche Map-Implementierungen mit unterschiedlichen Ordnungsgarantien, analog zu den drei Set-Varianten:

• HashMap: schnellster Zugriff, KEINE garantierte Reihenfolge — Standardwahl, wenn Reihenfolge egal ist.
• LinkedHashMap: Einfügereihenfolge (oder Zugriffsreihenfolge), minimal langsamer als HashMap.
• TreeMap: immer nach Schlüssel sortiert (natürliche Ordnung oder eigener Comparator), langsamer (O(log n) statt O(1)).

Praktisches Beispiel: Worthäufigkeiten in Einfügereihenfolge

Ein Anwendungsfall, bei dem die Reihenfolge tatsächlich zählt: die erste Reihenfolge, in der verschiedene Wörter zum ersten Mal auftauchen, soll erhalten bleiben, während trotzdem schnell gezählt wird:

Map<String, Integer> haeufigkeit = new LinkedHashMap<>();
for (String wort : text.split("\\s+")) {
    haeufigkeit.merge(wort, 1, Integer::sum); // zählt hoch, ohne containsKey() vorab
}
// Ausgabe erfolgt in der Reihenfolge, in der Wörter zum ERSTEN Mal auftauchten
haeufigkeit.forEach((wort, anzahl) -> System.out.println(wort + ": " + anzahl));

Mit einer normalen HashMap wäre die Ausgabereihenfolge hier unvorhersehbar — für reproduzierbare, nachvollziehbare Ausgaben (z. B. in Tests oder Logs) ist LinkedHashMap deshalb oft die bessere Wahl, selbst wenn die eigentliche Reihenfolge fachlich nicht zwingend wichtig wäre.

Siehe auch: HashSet, Collections