</>wiki.wendler.io

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
# 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**:

```java
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.

## Einige Snippets zur Benutzung von HashMap

### Wert zu Key hinzufuegen
```java
map.put(k,v)
```

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

```
### Wert eines key abfragen
```java
map.get(k)
```

```java
import java.util.HashMap;

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

```
### Anzahl der Key-Value Paare ausgeben lassen

```java
map.size()
```

```java
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());
    }
}
```
### Eintrag entfernen
```java
map.remove(k)
```
```java
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);
    }
}
```
### Alle Eintraege entfernen
```java
map.clear()
```
```java
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);
    }
}

```

### Über alle Values der HashMap iterieren
```java
map.values()
```
```java
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 und TreeMap
`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.)
```java
SortedMap<K,V> map = new TreeMap<>()
```
```java
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);
    }
}

```

#### Comperator
Der `Comperator` wird dem Konstruktor der `TreeMap` übergeben.
```java
SortedMap<String, Integer> sortedMap = new TreeMap<>(Comparator.reverseOrder());
```
```java
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);
    }
}

```


### Über alle Key-Value-Paare einer Map per forech-Loop iterieren
Mit einer `foreach-loop` kann über alle Einträge, das `entrySet()` iteriert werden.  
Ein einzelnes `key-value`-Paar ist vom Datentyp `Map.Entry<>`.
```java
for (Map.Entry<String,Integer> e : map.entrySet()) {
    String s = e.getKey();
    Integer i = e.getValue();
}
```
```java
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());
        }
    }
}
```

### Ueberpruefen, ob bestimmte keys oder values vorhanden sind.
```java
map.containsKey(k);
map.containsValue(v);
```
```java
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));
    }
}

```

### Vor Änderung eines Values sicherstellen, dass ein Eintrag überhaupt existiert
Der `value` eines Eintrags ist nur zu ändern, wenn er überhaupt schon besteht.
```java
map.containsKey(...)
```
```java
...
    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);
    }
...
```
### Standardwerte verwenden
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.
```java
map.getOrDefault(...);
```
```java
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);
    }
}

```