Les maps en Java

En Java, les maps sont des structures de données qui associent des clés à des valeurs, permettant de stocker, d’accéder, de mettre à jour et de supprimer efficacement des paires clé-valeur. Contrairement aux collections qui stockent uniquement des éléments, les maps maintiennent une relation d’association dans laquelle chaque clé est unique et pointe vers une seule valeur, même si plusieurs clés peuvent être associées à la même valeur.

L’interface Map fournit des mécanismes permettant d’obtenir des valeurs à partir de clés uniques (non dupliquées). Elle fournit également trois vues de collection qui permettent de manipuler le contenu d’une map de différentes manières : comme un ensemble de clés, une collection de valeurs ou un ensemble d’associations entre clés et valeurs. La principale interface dérivée de Map est SortedMap, qui représente les maps triées, ainsi que sa sous-interface NavigableMap. Map est largement utilisée par les classes de la bibliothèque standard. Les principales classes qui implémentent l’interface Map pour les maps non concurrentes sont HashMap, LinkedHashMap et TreeMap. Pour les maps concurrentes, les principales classes sont ConcurrentHashMap et ConcurrentSkipListMap.

Voici un extrait de la définition de l’interface Map, contenant uniquement les principales méthodes :

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...)
}

L’exemple suivant montre une map de voitures dont les clés sont les plaques d’immatriculation et dont les valeurs sont les noms des modèles correspondants. Avec cette map, nous pouvons par exemple vérifier si un élément donné existe en utilisant la clé comme paramètre de la méthode containsKey. De plus, la méthode get permet d’obtenir la valeur associée à la clé passée en paramètre, et la méthode remove supprime l’entrée de la 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...

En plus des méthodes décrites ci-dessus, il existe également plusieurs méthodes default qui fournissent des fonctionnalités supplémentaires.

L’interface fournit également des méthodes permettant de créer des maps immuables à partir de valeurs fournies (les méthodes of et ofEntries, ainsi que la méthode auxiliaire entry) ou à partir d’une map existante (copyOf).

La figure 1 présente l’interface Map et ses principales sous-interfaces. Les sous-interfaces directes de Map sont SequencedMap, Bindings et ConcurrentMap. Indirectement, SortedMap, NavigableMap et ConcurrentNavigableMap sont également des interfaces dérivées de Map (cette dernière est aussi une sous-interface de ConcurrentMap).

Parmi les descendants les plus importants de Map figurent les interfaces SortedMap et NavigableMap.

L’interface SortedMap est une extension de l’interface SequencedMap qui représente des maps dont les clés sont maintenues dans un ordre déterminé, selon l’ordre naturel des clés ou selon un comparateur spécifique fourni lors de la création de la map. Sa seule sous-interface directe dans le framework Collections, NavigableMap, ajoute des méthodes offrant des opérations de navigation plus avancées pour manipuler les clés d’une map, comme l’obtention de la clé la plus proche d’une valeur donnée ou le parcours de la map dans l’ordre croissant ou décroissant.

En pratique, nous utilisons couramment NavigableMap plutôt que SortedMap, puisque les deux classes qui implémentent SortedMap dans le framework Collections le font indirectement (TreeMap implémente NavigableMap, et ConcurrentSkipListMap implémente ConcurrentNavigableMap). NavigableMap va un peu plus loin en termes de fonctionnalités, en fournissant des méthodes spécifiques pour naviguer dans la map, de manière analogue à ce que NavigableSet fournit pour les ensembles.

---

Cet article est une adaptation de contenu du livre Orientação a Objetos com Java, de Eduardo Kessler Piveta