« Dictionnaire personnel » — HashMap<K,V>

1. Introduction

Nous savons déjà que ArrayList est un « tableau extensible » qui grandit tout seul. Mais il a une limitation : l’accès aux éléments se fait par numéro (indice). Si nous avons une liste de mille personnes et que nous voulons trouver le numéro de téléphone d’Alice, il faudra soit connaître son indice, soit parcourir tout le monde.

Dans la vie, nous cherchons souvent des données par un identifiant unique :

• on cherche un numéro de téléphone par le nom,
• on trouve le propriétaire par le numéro de passeport,
• on trouve le mot de passe par le login,
• on cherche un objet en base par son id.

Pour cela, il faut une structure capable de faire : « j’ai une clé → je trouve immédiatement la valeur ». En Java, c’est le rôle de HashMap<K,V>.

Analogie :
Imaginez un dictionnaire papier. Vous cherchez la traduction de « house ». Vous n’avez pas besoin de feuilleter toutes les pages. Vous allez directement à la lettre « H » et trouvez le mot. HashMap fonctionne de la même manière : par la clé (le mot), on obtient instantanément la valeur (la traduction).

Création du dictionnaire

Pour créer un dictionnaire, vous devez indiquer quels types seront les clés et les valeurs.

import java.util.HashMap;

HashMap<String, String> phonebook = new HashMap<String, String>();

Ici :

• String (le premier type) est le type de la clé (le nom de la personne).
• String (le second type) est le type de la valeur (le numéro de téléphone).

Désormais, phonebook est comme un véritable annuaire téléphonique.

Autres exemples :

HashMap<String, Integer> grades = new HashMap<String, Integer>();  // nom → note
HashMap<Integer, String> users = new HashMap<Integer, String>();   // id → nom
HashMap<String, Boolean> flags = new HashMap<String, Boolean>();   // clé → valeur booléenne

Contrairement à ArrayList, un dictionnaire n’a pas de méthode add(), mais il a ses propres méthodes tout aussi intéressantes.

2. Méthode put(key, value) — ajouter une paire

La principale différence entre HashMap et les tableaux/listes est qu’il stocke non pas un simple ensemble de valeurs, mais des paires clé–valeur. Cela le rend semblable à un vrai dictionnaire : chaque mot a une traduction, chaque nom a un téléphone, chaque login a un mot de passe.

Exemple :

phonebook.put("Alice", "+380501112233");
phonebook.put("Bob", "+380671234567");

À présent, dans notre annuaire téléphonique :

• la clé "Alice" est associée à la valeur "+10501112233",
• la clé "Bob" est associée à la valeur "+10671234567".

Cela signifie que, pour obtenir la valeur (le téléphone), il suffit de connaître la clé (le nom).

À retenir : les clés sont uniques. Si nous essayons d’ajouter une nouvelle valeur pour une clé existante, l’ancienne valeur sera écrasée.

phonebook.put("Alice", "+10999999999");

Désormais, Alice n’a plus que le nouveau numéro : l’ancien a été perdu.

Conclusion : put est la méthode pour ajouter ou mettre à jour des entrées. Si la clé est nouvelle — l’entrée est créée. Si la clé existe déjà — l’entrée est mise à jour.

3. Méthode get(key) — obtenir une valeur

Pour retrouver une valeur, il faut connaître la clé. C’est la force de HashMap : la recherche par clé est très rapide, quasiment instantanée, qu’on ait mille ou un million d’entrées.

Exemple :

System.out.println(phonebook.get("Alice"));

Sortie :

+10501112233

Si une telle clé n’existe pas, get renverra null :

System.out.println(phonebook.get("Charlie")); // null

Cela signifie : « la clé "Charlie" n’est pas présente dans le dictionnaire ».

4. Méthode containsKey(key) — vérifier la présence

Pour éviter de tomber sur null, il est utile de vérifier d’abord si la clé est dans le dictionnaire.

Exemple :

System.out.println(phonebook.containsKey("Charlie"));

Sortie :

false

De cette façon, nous pouvons anticiper :

• si la clé n’existe pas — on crée une nouvelle entrée,
• si la clé existe — on la met à jour.

Schéma courant :

if (phonebook.containsKey("Alice")) 
{
    System.out.println("Alice a déjà un numéro!");
} 
else 
{
    phonebook.put("Alice", "+10111111111");
}

5. Méthode remove(key) — supprimer une entrée

La suppression est tout aussi simple : il suffit de connaître la clé.

phonebook.remove("Bob");
System.out.println(phonebook.get("Bob"));

Sortie :

null

Il n’y a donc plus d’entrée avec la clé "Bob" dans le dictionnaire.

6. Parcourir toutes les paires

Il est souvent nécessaire non seulement d’obtenir des données par une clé précise, mais aussi d’afficher tout le dictionnaire. Pour cela, on utilise la méthode entrySet().

for (var entry : phonebook.entrySet()) {
    System.out.println(entry.getKey() + " -> " + entry.getValue());
}

Exemple de sortie :

Alice -> +10501112233

On obtient ainsi directement accès à la clé (entry.getKey()) et à la valeur (entry.getValue()).

7. Pratique : comptage des mots

Prenons un exercice classique — compter le nombre d’occurrences des mots dans un texte. C’est l’un des exemples les plus parlants de l’utilité d’une HashMap.

String text = "java java core java";
HashMap<String, Integer> freq = new HashMap<String, Integer>();

for (String w : text.split(" ")) 
{
    Integer old = freq.get(w);
    freq.put(w, (old == null) ? 1 : old + 1);
}

System.out.println(freq);

Sortie :

{core=1, java=3}

Analysons pas à pas ce qui se passe :

1. Nous avons séparé la chaîne "java java core java" en mots.
2. Pour chaque mot, nous vérifions s’il est déjà dans le dictionnaire (freq.get(w)).
3. S’il n’y est pas (null), c’est la première occurrence du mot → nous mettons 1.
4. S’il y est, cela signifie qu’il est déjà apparu → nous incrémentons la valeur de un.

Cas d’usage réels :

• compter le nombre d’appels à une API,
• statistiques de fréquence des mots dans un texte,
• stockage des quantités d’articles en entrepôt.

8. Pratique : annuaire téléphonique

Écrivons une application un peu plus grande.

import java.util.HashMap;
import java.util.Scanner;

public class PhonebookApp {
    public static void main(String[] args) 
    {
        HashMap<String, String> phonebook = new HashMap<String, String>();
        Scanner console = new Scanner(System.in);

        while (true) 
        {
            System.out.print("Saisissez un nom (ou une ligne vide pour quitter): ");
            String name = console.nextLine();
            if (name.isEmpty()) break;

            System.out.print("Saisissez le numéro: ");
            String phone = console.nextLine();

            phonebook.put(name, phone);
        }

        System.out.println("Annuaire téléphonique:");
        for (var entry : phonebook.entrySet()) 
        {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
    }
}

Le programme fonctionne comme un mini-répertoire. Vous saisissez des noms et des numéros, ils sont stockés dans la HashMap. À la fin, vous pouvez afficher toute la liste. Les dictionnaires sont très souvent utilisés dans des projets réels.