Java HashMap : put, get, parcourir et patterns courants

Une Map stocke des paires clé-valeur

Une HashMap (de java.util) stocke des associations : chaque clé est associée à une valeur, et vous recherchez les valeurs par leur clé en temps quasi constant. Pensez à un dictionnaire : le mot est la clé, la définition est la valeur.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        System.out.println(ages.get("Boris"));
        System.out.println(ages);
    }
}

Les deux paramètres de type sont <KeyType, ValueType>. Ici, les clés sont des String et les valeurs des Integer. Comme avec ArrayList, vous typez généralement la variable avec l'interface Map et construisez une HashMap.

put, get et écrasement

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);
        stock.put("apples", 75);   // même clé -> écrase l'ancienne valeur

        System.out.println(stock.get("apples"));  // 75
        System.out.println(stock.get("pears"));    // null - clé absente
    }
}

Deux choses à intégrer :

• Une clé est unique. put avec une clé existante remplace sa valeur et renvoie l'ancienne.
• get sur une clé absente renvoie null, pas une erreur. L'auto-unboxing de ce null en un int lève une NullPointerException, une source courante de bugs.

getOrDefault évite le piège du null

Plutôt que de vérifier null à chaque fois, demandez une valeur par défaut :

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);

        int apples = stock.getOrDefault("apples", 0);
        int pears = stock.getOrDefault("pears", 0);

        System.out.println(apples + " apples, " + pears + " pears");
    }
}

C'est la manière la plus propre de gérer les recherches « peut-être présentes », et cela mène directement au pattern le plus célèbre des HashMap.

Compter les occurrences

Compter combien de fois chaque élément apparaît est la tâche par excellence d'une HashMap :

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        String text = "the cat the dog the cat";
        Map<String, Integer> counts = new HashMap<>();

        for (String word : text.split(" ")) {
            counts.put(word, counts.getOrDefault(word, 0) + 1);
        }

        System.out.println(counts);
    }
}

Le pattern map.put(key, map.getOrDefault(key, 0) + 1) se lit « prends le compte actuel (ou zéro), ajoute un, puis remets-le en place ». Un équivalent plus élégant est counts.merge(word, 1, Integer::sum).

Vérifier et supprimer

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        System.out.println(ages.containsKey("Ada"));     // true
        System.out.println(ages.containsValue(29));      // true
        System.out.println(ages.size());                 // 2

        ages.remove("Ada");
        System.out.println(ages.containsKey("Ada"));     // false
    }
}

putIfAbsent(key, value) n'écrit que lorsque la clé est absente, utile pour l'initialisation paresseuse.

Parcourir une HashMap

La boucle la plus courante parcourt entrySet(), vous donnant chaque clé et valeur ensemble :

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Si vous n'avez besoin que des clés ou que des valeurs :

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        for (String name : ages.keySet()) {
            System.out.println(name);
        }
        for (int age : ages.values()) {
            System.out.println(age);
        }
    }
}

Vous pouvez aussi utiliser forEach avec une lambda : ages.forEach((name, age) -> System.out.println(name + ": " + age));.

La HashMap ne conserve pas l'ordre

Une HashMap ne garantit aucun ordre d'itération : c'est celui que produit le hachage, et il peut changer d'une exécution à l'autre. Si vous avez besoin d'un ordre prévisible :

• LinkedHashMap préserve l'ordre d'insertion.
• TreeMap maintient les clés triées selon leur ordre naturel (ou un Comparator que vous fournissez).

Les trois implémentent l'interface Map, donc passer de l'une à l'autre ne demande qu'une seule ligne à modifier dans le constructeur.

Les clés doivent être hachables

HashMap trouve les entrées en hachant la clé, donc les méthodes hashCode() et equals() d'une clé doivent être cohérentes entre elles. Les types intégrés comme String et Integer le font déjà correctement. Si vous utilisez votre propre classe comme clé, redéfinissez à la fois equals et hashCode ; sinon, deux objets « égaux » par leur sens atterriront dans des compartiments différents et vos recherches échoueront de façon mystérieuse.

Ensuite : HashSet

Une HashMap répond à « quelle valeur est stockée sous cette clé ? ». Quand vous voulez seulement savoir si quelque chose est présent ou non (un ensemble de valeurs uniques, sans données associées), l'outil est HashSet, qui arrive ensuite.