HashMap en français

Qu'est-ce qu'un HashMap ?

Une instance de la classe HashMap implémente l'interface Map, ce qui signifie qu'elle stocke des éléments en paires clé-valeur. Contrairement à un TreeMap, qui organise ses éléments dans un ordre bien défini, le HashMap ne garantie aucun ordre particulier. En réalité, les éléments d'un HashMap sont triés en fonction des hachages de leurs clés, ce qui semble aléatoire pour la plupart des situations. Cela est dû aux différentes méthodes de stockage interne que chaque collection utilise. Tandis que le HashMap repose sur des hachages pour effectuer des recherches, le TreeMap utilise une structure d'arbre binaire. Le principal atout du HashMap réside dans la vitesse de ses opérations, qui est généralement plus rapide.

Syntaxe

Pour utiliser un HashMap, il convient d'importer la classe depuis le package java.util. Voici comment on peut initialiser un HashMap avec des types génériques apportés dans les chevrons < ... >. On peut choisir que les types de données pour les clés et les valeurs soient similaires ou différents.

import java.util.HashMap;

HashMap monHashMap = new HashMap();

Accéder aux éléments

Les clés servent à identifier de manière unique une valeur dans un HashMap, facilitant ainsi le stockage et l'accès aux données. Prenons l'exemple suivant où les noms des cours sont utilisés comme clés et les enseignants assignés comme valeurs accessibles via la méthode .get().

// Main.java
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap coursEnseignant = new HashMap();
        coursEnseignant.put("Histoire", "Ben");
        coursEnseignant.put("Mathématiques", "Jeanette");
        coursEnseignant.put("Physique", "Lily");
        System.out.println(coursEnseignant.get("Physique"));
        System.out.println(coursEnseignant.get("Histoire"));
    }
}

Cela imprimera :

Lily
Ben

Ajouter des éléments

Pour ajouter des éléments dans un HashMap, on utilise la méthode .put(), qui nécessite deux attributs : une clé et une valeur, que le HashMap enregistre sous forme de paire ({ clé=valeur }). Voici un exemple :

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap coursEnseignant = new HashMap();
        coursEnseignant.put("Histoire", "Ben");
        coursEnseignant.put("Mathématiques", "Jeanette");
        coursEnseignant.put("Physique", "Lily");
        System.out.println(coursEnseignant);
    }
}

La sortie ressemblera à ceci :

{Histoire=Ben, Mathématiques=Jeanette, Physique=Lily}

Supprimer des éléments

Pour supprimer un élément d'un HashMap, on peut utiliser la méthode .remove(), qui prend comme paramètre la clé correspondant à la paire clé-valeur à supprimer.

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap coursEnseignant = new HashMap();
        coursEnseignant.put("Histoire", "Ben");
        coursEnseignant.put("Mathématiques", "Jeanette");
        coursEnseignant.put("Physique", "Lily");
        coursEnseignant.remove("Physique");
        System.out.println(coursEnseignant);
    }
}

L'output sera :

{Histoire=Ben, Mathématiques=Jeanette}

Supprimer tous les éléments

La méthode .clear() permet d'effacer tous les éléments contenus dans le HashMap.

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap coursEnseignant = new HashMap();
        coursEnseignant.put("Histoire", "Ben");
        coursEnseignant.put("Mathématiques", "Jeanette");
        coursEnseignant.put("Physique", "Lily");
        coursEnseignant.clear();
        System.out.println(coursEnseignant);
    }
}

Cela produira une sortie vide :

{}

Parcourir un HashMap avec .keySet()

Il est possible de parcourir un HashMap avec une boucle for-each. En utilisant la méthode .keySet(), on obtient uniquement les clés, tandis que .values() permet d'obtenir uniquement les valeurs.

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap coursEnseignant = new HashMap();
        coursEnseignant.put("Histoire", "Ben");
        coursEnseignant.put("Mathématiques", "Jeanette");
        coursEnseignant.put("Physique", "Lily");
        System.out.println("Cours offerts à notre Institut :");
        for (String i : coursEnseignant.keySet()) {
            System.out.println(i);
        }
        System.out.println("\nEnseignants à notre Institut :");
        for (String i : coursEnseignant.values()) {
            System.out.println(i);
        }
    }
}

L'output sera :

Cours offerts à notre Institut :
Mathématiques
Histoire
Physique
Enseignants à notre Institut :
Jeanette
Ben
Lily

Parcourir un HashMap avec .entrySet()

Alternativement, on peut utiliser Map.Entry() pour récupérer un ensemble de paires clé-valeur. Cela peut être plus efficace si l'on a besoin d'accéder à la clé et à la valeur en même temps.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        HashMap coursEnseignant = new HashMap();
        coursEnseignant.put("Histoire", "Ben");
        coursEnseignant.put("Mathématiques", "Jeanette");
        coursEnseignant.put("Physique", "Lily");
        for (Map.Entry entry : coursEnseignant.entrySet()) {
            System.out.printf("Cours : %s ", entry.getKey());
            System.out.printf("Enseignant : %s \n", entry.getValue());
        }
    }
}

Cet exemple produira la sortie suivante :

Cours : Mathématiques Enseignant : Jeanette
Cours : Histoire Enseignant : Ben
Cours : Physique Enseignant : Lily