Maps in Java

Maps sind in Java Datenstrukturen, die Schlüssel mit Werten verknüpfen und dadurch das Speichern, Abrufen, Aktualisieren und Entfernen von Schlüssel-Wert-Paaren ermöglichen. Im Gegensatz zu Collections, die nur Elemente speichern, unterhalten Maps eine Zuordnung, bei der jeder Schlüssel eindeutig ist und auf genau einen Wert verweist, auch wenn Werte mehrfach vorkommen können.

Das Interface Map stellt Mechanismen bereit, um Werte über eindeutige (nicht duplizierte) Schlüssel abzurufen. Das Interface Map stellt drei Collection-Sichten bereit, mit denen der Inhalt einer Map auf unterschiedliche Weise bearbeitet werden kann: als Menge von Schlüsseln, als Collection von Werten oder als Menge von Zuordnungen zwischen Schlüsseln und Werten. Das wichtigste von Map abgeleitete Interface ist SortedMap, das sortierte Maps repräsentiert, sowie dessen Subinterface NavigableMap. Map wird von vielen Klassen der Standardbibliothek verwendet. Die wichtigsten Klassen, die das Map-Interface für nicht nebenläufige Maps implementieren, sind HashMap, LinkedHashMap und TreeMap. Für nebenläufige Maps sind ConcurrentHashMap und ConcurrentSkipListMap die wichtigsten Klassen.

Im Folgenden ist ein Ausschnitt aus der Definition des Map-Interfaces zu sehen, der nur die wichtigsten Methoden enthält:

public interface Map<K,V>{
    // Query Operations
    int size();
    boolean isEmpty();
    boolean containsKey(Object key);
    boolean containsValue(Object value);
    V get(Object key);

    // Modification Operations
    V put(K key, V value);
    V remove(Object key);
    void putAll(Map<? extends K, ? extends V> m);
    void clear();

    // Views
    Set<K> keySet();
    Collection<V> values();
    Set<Map.Entry<K, V>> entrySet();

    // Definition of the Entry interface
    interface Entry<K, V> {
        // Body omitted
    }

    // (continues...)
}

Das folgende Beispiel zeigt eine Map von Autos, deren Schlüssel Kennzeichen und deren Werte die Namen der entsprechenden Automodelle sind. Mit dieser Map können wir beispielsweise prüfen, ob ein bestimmtes Element vorhanden ist, indem wir den Schlüssel als Parameter der Methode containsKey verwenden. Außerdem liefert die Methode get den mit dem als Parameter übergebenen Schlüssel verbundenen Wert, und die Methode remove entfernt den Eintrag aus der Map:

void main() {
    Map<String, String> cars = new HashMap<>();
    cars.put("ABCD2935", "Tesla Model S");
    cars.put("YJKF9353", "Toyota Corolla");
    cars.put("WFLO1304", "Honda CRV");

    var key = "ABCD2935";

    if (cars.containsKey(key)){
        IO.println("Vehicle data:");
        IO.println(cars.get(key));
        IO.println("Removing the vehicle...");
        cars.remove(key);
    } else
        IO.println("Vehicle not found!");
}

Vehicle data:
Tesla Model S
Removing the vehicle...

Neben den oben beschriebenen Methoden gibt es auch mehrere Default-Methoden, die zusätzliche Funktionalität bereitstellen.

Das Interface stellt außerdem Methoden bereit, um unveränderliche Maps aus angegebenen Werten (of und ofEntries sowie die Hilfsmethode entry) oder aus einer vorhandenen Map (copyOf) zu erzeugen.

Abbildung 1 zeigt das Map-Interface und seine wichtigsten Subinterfaces. Die direkten Subinterfaces von Map sind SequencedMap, Bindings und ConcurrentMap. Indirekt sind auch SortedMap, NavigableMap und ConcurrentNavigableMap von Map abgeleitet (letzteres ist außerdem ein Subinterface von ConcurrentMap).

Zu den wichtigsten Nachkommen von Map gehören die Interfaces SortedMap und NavigableMap.

Das Interface SortedMap ist eine Erweiterung des Interfaces SequencedMap und repräsentiert Maps, die ihre Schlüssel in einer bestimmten Reihenfolge halten, entsprechend der natürlichen Ordnung der Schlüssel oder einem bestimmten Comparator, der beim Erzeugen der Map angegeben wird. Sein einziges direktes Subinterface im Collections Framework, NavigableMap, fügt Methoden für fortgeschrittenere Navigationsoperationen hinzu, beispielsweise zum Ermitteln des Schlüssels, der einem bestimmten Wert am nächsten liegt, oder zum Durchlaufen der Map in auf- oder absteigender Reihenfolge.

In der Praxis verwenden wir häufig NavigableMap statt SortedMap, da beide Klassen, die SortedMap im Collections Framework implementieren, dies indirekt tun (TreeMap implementiert NavigableMap, und ConcurrentSkipListMap implementiert ConcurrentNavigableMap). NavigableMap bietet einen etwas größeren Funktionsumfang und stellt spezifische Methoden zur Navigation durch die Map bereit, ähnlich wie NavigableSet für Mengen.

---

Dieser Artikel ist eine Adaption von Inhalten aus dem Buch Orientação a Objetos com Java von Eduardo Kessler Piveta