Comment vérifier si une Map Java contient une clé spécifique

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier efficacement si une clé spécifique existe dans une Map Java. Cette compétence est essentielle pour éviter les erreurs et garantir des opérations robustes sur les cartes (maps).

Nous allons explorer la méthode fondamentale containsKey() pour vérifier la présence d'une clé, démontrer son utilisation avec différents types de clés et aborder la question de la gestion des clés null, afin de vous offrir une compréhension complète de la vérification des clés dans les cartes Java.

Utiliser containsKey() pour vérifier une clé

Dans cette étape, nous allons apprendre à vérifier si une clé spécifique existe dans une HashMap en utilisant la méthode containsKey(). Il s'agit d'une opération fondamentale lorsqu'on travaille avec des cartes (maps), car elle vous permet d'éviter les erreurs qui pourraient survenir si vous essayez d'accéder à une clé qui n'existe pas.

Une HashMap est une structure de données en Java qui stocke des paires clé-valeur. Imaginez-la comme un dictionnaire où chaque mot (la clé) a une définition (la valeur). La méthode containsKey() revient à demander au dictionnaire : "Avez-vous une entrée pour ce mot spécifique ?"

Créons un simple programme Java pour démontrer comment utiliser containsKey().

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE. Si vous avez terminé le laboratoire (lab) précédent, ce fichier devrait déjà exister dans votre répertoire ~/project.

Remplacez le code existant dans HelloJava.java par le code suivant :

import java.util.HashMap;

public class HelloJava {
    public static void main(String[] args) {
        // Create a HashMap
        HashMap<String, String> userMap = new HashMap<>();

        // Add some key-value pairs
        userMap.put("alice", "Alice Smith");
        userMap.put("bob", "Bob Johnson");
        userMap.put("charlie", "Charlie Brown");

        // Check if a key exists using containsKey()
        String keyToCheck1 = "alice";
        String keyToCheck2 = "david";

        System.out.println("Checking for key: " + keyToCheck1);
        if (userMap.containsKey(keyToCheck1)) {
            System.out.println("Key '" + keyToCheck1 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck1 + "' does not exist in the map.");
        }

        System.out.println("\nChecking for key: " + keyToCheck2);
        if (userMap.containsKey(keyToCheck2)) {
            System.out.println("Key '" + keyToCheck2 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck2 + "' does not exist in the map.");
        }
    }
}

Examinons les nouvelles parties de ce code :

import java.util.HashMap; : Cette ligne importe la classe HashMap, que nous avons besoin d'utiliser pour les HashMap.
HashMap<String, String> userMap = new HashMap<>(); : Cette ligne crée une nouvelle HashMap où les clés et les valeurs sont de type String.
userMap.put("alice", "Alice Smith"); : Cela ajoute une paire clé-valeur à la carte. La clé est "alice" et la valeur est "Alice Smith".
userMap.containsKey(keyToCheck1) : C'est le cœur de cette étape. La méthode containsKey() prend une clé en argument et renvoie true si la clé est trouvée dans la carte, et false sinon.

Enregistrez le fichier HelloJava.java (Ctrl+S ou Cmd+S).
Maintenant, compilez le programme en utilisant la commande javac dans le terminal :
```
javac HelloJava.java
```
S'il n'y a pas d'erreurs, vous ne verrez aucun résultat.

Enfin, exécutez le programme compilé en utilisant la commande java :

java HelloJava

Vous devriez voir un résultat similaire à ceci :

Checking for key: alice
Key 'alice' exists in the map.

Checking for key: david
Key 'david' does not exist in the map.

Ce résultat confirme que containsKey() a correctement identifié si les clés "alice" et "david" étaient présentes dans notre userMap.

Tester avec différents types de clés

Dans l'étape précédente, nous avons utilisé des clés de type String dans notre HashMap. Cependant, une HashMap peut utiliser différents types de données comme clés, tant que ce sont des objets (les types primitifs comme int, char, etc., sont automatiquement "encapsulés" dans leurs objets wrapper correspondants comme Integer, Character).

Dans cette étape, nous allons explorer l'utilisation de différents types de données comme clés dans une HashMap et voir comment containsKey() fonctionne avec elles.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

Remplacez le code existant par le code suivant :

import java.util.HashMap;

public class HelloJava {
    public static void main(String[] args) {
        // Create a HashMap with Integer keys and String values
        HashMap<Integer, String> studentMap = new HashMap<>();

        // Add some key-value pairs
        studentMap.put(101, "Alice Smith");
        studentMap.put(102, "Bob Johnson");
        studentMap.put(103, "Charlie Brown");

        // Check for keys using containsKey() with Integer keys
        Integer keyToCheck1 = 101;
        Integer keyToCheck2 = 200; // A key that does not exist

        System.out.println("Checking for key: " + keyToCheck1);
        if (studentMap.containsKey(keyToCheck1)) {
            System.out.println("Key '" + keyToCheck1 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck1 + "' does not exist in the map.");
        }

        System.out.println("\nChecking for key: " + keyToCheck2);
        if (studentMap.containsKey(keyToCheck2)) {
            System.out.println("Key '" + keyToCheck2 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck2 + "' does not exist in the map.");
        }

        // You can also use primitive int directly, Java will auto-box it
        int primitiveKey = 102;
        System.out.println("\nChecking for primitive key: " + primitiveKey);
        if (studentMap.containsKey(primitiveKey)) {
             System.out.println("Key '" + primitiveKey + "' exists in the map.");
        } else {
             System.out.println("Key '" + primitiveKey + "' does not exist in the map.");
        }
    }
}

Dans ce code, nous avons créé une HashMap où les clés sont des objets Integer (représentant les identifiants d'étudiants) et les valeurs sont des objets String (représentant les noms d'étudiants). Nous utilisons ensuite containsKey() avec des objets Integer et un int primitif pour montrer que Java gère la conversion (auto-boxing) pour vous.

Enregistrez le fichier HelloJava.java.
Compilez le programme :
```
javac HelloJava.java
```

Exécutez le programme :

java HelloJava

Vous devriez voir un résultat similaire à ceci :

Checking for key: 101
Key '101' exists in the map.

Checking for key: 200
Key '200' does not exist in the map.

Checking for primitive key: 102
Key '102' exists in the map.

Cela démontre que containsKey() fonctionne correctement avec des clés Integer, et que la fonctionnalité d'auto-boxing de Java vous permet d'utiliser directement des valeurs int primitives lors de la vérification des clés dans une HashMap<Integer, ...>.

Gérer les clés null

Dans la HashMap de Java, vous pouvez en fait utiliser null comme clé, mais seule une clé null est autorisée. Il est important de comprendre le comportement de containsKey() lorsqu'il s'agit de clés null.

Dans cette étape, nous allons modifier notre programme pour inclure une clé null, puis utiliser containsKey() pour vérifier sa présence.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

Remplacez le code existant par le code suivant :

import java.util.HashMap;

public class HelloJava {
    public static void main(String[] args) {
        // Create a HashMap that allows null keys
        HashMap<String, String> statusMap = new HashMap<>();

        // Add some key-value pairs, including a null key
        statusMap.put("active", "User is currently online");
        statusMap.put("inactive", "User is offline");
        statusMap.put(null, "User status is unknown"); // Adding a null key

        // Check for keys using containsKey(), including null
        String keyToCheck1 = "active";
        String keyToCheck2 = "pending"; // A key that does not exist
        String keyToCheck3 = null;      // The null key

        System.out.println("Checking for key: " + keyToCheck1);
        if (statusMap.containsKey(keyToCheck1)) {
            System.out.println("Key '" + keyToCheck1 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck1 + "' does not exist in the map.");
        }

        System.out.println("\nChecking for key: " + keyToCheck2);
        if (statusMap.containsKey(keyToCheck2)) {
            System.out.println("Key '" + keyToCheck2 + "' exists in the map.");
        } else {
            System.out.println("Key '" + keyToCheck2 + "' does not exist in the map.");
        }

        System.out.println("\nChecking for null key:");
        if (statusMap.containsKey(keyToCheck3)) {
            System.out.println("Null key exists in the map.");
        } else {
            System.out.println("Null key does not exist in the map.");
        }
    }
}

Ici, nous avons créé une HashMap avec des clés et des valeurs de type String. Nous ajoutons ensuite explicitement une clé null en utilisant statusMap.put(null, "User status is unknown");. Enfin, nous utilisons containsKey(null) pour vérifier si la clé null est présente.

Enregistrez le fichier HelloJava.java.
Compilez le programme :
```
javac HelloJava.java
```

Exécutez le programme :

java HelloJava

Vous devriez voir un résultat similaire à ceci :

Checking for key: active
Key 'active' exists in the map.

Checking for key: pending
Key 'pending' does not exist in the map.

Checking for null key:
Null key exists in the map.

Ce résultat confirme que containsKey() identifie correctement la présence de la clé null dans la HashMap. Bien qu'il soit possible d'utiliser des clés null, il est souvent recommandé de les éviter si possible pour rendre votre code plus clair et prévenir les problèmes potentiels de NullPointerException dans d'autres parties de votre programme.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une clé spécifique existe dans une HashMap Java en utilisant la méthode containsKey(). Cette opération fondamentale est essentielle pour éviter les erreurs lors de l'accès aux éléments d'une carte (map). Nous avons pratiqué l'utilisation de containsKey() avec des clés de type chaîne de caractères (string) et avons observé comment elle identifie correctement les clés existantes et non existantes.