HashMaps: Schlüssel-Wert-Paare

HashMaps sind eine weitere Datenstruktur, die bereits mit der JDK ausgeliefert werden. Sie funktionieren wie die Einträge in einem Wörterbuch: Unter einem Stichwort findet man eine Erklärung:

Eintrag1: Erklärung
Eintrag2: Erklärung
...
Eintrag1244: Erklärung

Die einzelnen Einträge in eine HashMap heißen nun nicht so, sonder sind Schlüssel-Werte-Paare, oder auf englisch: key-value. Für jeden key wird ein value gespeichert.

Es ist üblich, key und value mit k,v abzukürzen

Beachte: Um eindeutige Ergebnisse liefern zu können, kann jeder key nur ein mal vergeben werden. Sollten mehrere values unter einem key gespeichert werden (Spoiler: Das ist gar nicht so selten), muss als value wiederum eine Datenstruktur gewählt werden, die das Speichern von mehreren Werten zulässt, wie zum Beispiel ArrayList.

So kannst du unter Angabe des key den damit verknüpften value gelierfert bekommen.

Vorteile von HashMaps:

• Schneller Zugriff: Du kannst einen Wert mit seinem Schlüssel in konstanter Zeit (O(1)) abrufen, d.h., auch bei sehr vielen Einträgen wird der Suchvorgang schnell laufen.
• Flexibilität: Du kannst verschiedene Datentypen für Schlüssel und Werte verwenden.
• Dynamische Größe: HashMaps können automatisch wachsen, wenn du neue Einträge hinzufügst.

map.put(k,v)

import java.util.HashMap;
 
public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Apfel", 3);
        map.put("Banane", 2);
    }
}

map.get(k)

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

map.size()

import java.util.HashMap;
 
public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Apfel", 3);
        map.put("Banane", 2);
        System.out.println("Anzahl der Paare: " + map.size());
    }
}

map.remove(k)

import java.util.HashMap;
 
public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Apfel", 3);
        map.put("Banane", 2);
 
        map.remove("Banane");
        System.out.println(map);
    }
}

map.clear()

import java.util.HashMap;
 
public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Apfel", 3);
        map.put("Banane", 2);
        map.clear();
        System.out.println(map);
    }
}

map.values()

import java.util.HashMap;
 
public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Apfel", 3);
        map.put("Banane", 2);
        map.put("Orange", 5);
 
        int summe = 0;
        for (int wert : map.values()) {
            summe += wert;
        }
        System.out.println("Summe der Werte: " + summe);
    }
}

SortedMap ist eine spezielle Map, die die einzelnen key-value-Paare sortiert ausgeben kann. Hierfür kann bei Bedarf ein Comperator eingefügt werden (s.u.)

SortedMap<K,V> map = new TreeMap<>()

import java.util.SortedMap;
import java.util.TreeMap;
 
public class Main {
    public static void main(String[] args) {
        SortedMap<String, Integer> sortedMap = new TreeMap<>();
 
        sortedMap.put("Apfel", 3);
        sortedMap.put("Banane", 2);
        sortedMap.put("Orange", 5);
 
        System.out.println(sortedMap);
    }
}

Der Comperator wird dem Konstruktor der TreeMap übergeben.

SortedMap<String, Integer> sortedMap = new TreeMap<>(Comparator.reverseOrder());

import java.util.SortedMap;
import java.util.TreeMap;
import java.util.Comparator;
 
public class Main {
    public static void main(String[] args) {
        SortedMap<String, Integer> sortedMap = new TreeMap<>(Comparator.reverseOrder());
        sortedMap.put("Apfel", 3);
        sortedMap.put("Banane", 2);
        sortedMap.put("Orange", 5);
 
        System.out.println(sortedMap);
    }
}

Mit einer foreach-loop kann über alle Einträge, das entrySet() iteriert werden. Ein einzelnes key-value-Paar ist vom Datentyp Map.Entry<>.

for (Map.Entry<String,Integer> e : map.entrySet()) {
    String s = e.getKey();
    Integer i = e.getValue();
}

public class HashEntries {
        public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Apfel", 3);
        map.put("Banane", 2);
        map.put("Clementine", 2);
        map.put("Xantippe", 2);
        map.put("Zote", 2);
 
        for (Map.Entry<String,Integer> e : map.entrySet()) {
            System.out.println(e.getKey() + " ... " + e.getValue());
        }
    }
}

map.containsKey(k);
map.containsValue(v);

import java.util.HashMap;
 
public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Apfel", 3);
        map.put("Banane", 2);
        System.out.println("Enthält Apfel: " + map.containsKey("Apfel"));
        System.out.println("Enthält Wert 2: " + map.containsValue(2));
    }
}

Der value eines Eintrags ist nur zu ändern, wenn er überhaupt schon besteht.

map.containsKey(...)

...
    if(map.containsKey(word)){
        Integer v = map.get(word);
        map.put(word,v+1);
    }
    else{
        // wenn Eintrag nicht vorhanden:
        // mit Standardwert initialisieren
        map.put(word,1);
    }
...

Den Prozess des Überprüfens, ob ein Eintrag besteht, kann man abkürzen, indem man mit getOrDefault() einfach als zweiten Parameter einen Wert übergibt, der zurückgegeben werden soll, wenn der Eintrag noch nicht bestehen sollte.

map.getOrDefault(...);

import java.util.HashMap;
 
public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Apfel", 3);
        map.put("Banane", 2);
 
        int wert = map.getOrDefault("Orange", 0);
        System.out.println("Wert für 'Orange': " + wert);
    }
}