Comment vérifier si une carte contient une valeur spécifique en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une valeur spécifique existe dans une HashMap en Java. Nous allons explorer la pratique méthode containsValue() fournie par la classe HashMap, qui détermine efficacement si une valeur est présente.

En outre, nous examinerons comment parcourir manuellement les valeurs de la carte pour effectuer la vérification, offrant une approche alternative. Enfin, nous discuterons de la manière de gérer les valeurs null lors de la vérification de leur présence dans la carte.

Utiliser containsValue() pour vérifier une valeur

Dans cette étape, nous allons explorer comment vérifier si une valeur spécifique existe dans une HashMap en Java. Une HashMap est une structure de données très utile qui stocke des paires clé-valeur. Parfois, vous pourriez avoir besoin de savoir si une valeur particulière est présente dans la carte, indépendamment de sa clé.

La classe HashMap de Java fournit une méthode pratique appelée containsValue() à cet effet. Cette méthode prend une valeur en argument et renvoie true si la carte contient au moins une association clé-valeur où la valeur est égale à la valeur spécifiée. Sinon, elle renvoie false.

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

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.
Remplacez tout le contenu du fichier par le code suivant :
```
import java.util.HashMap;

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

        // Add some key-value pairs
        ages.put("Alice", 30);
        ages.put("Bob", 25);
        ages.put("Charlie", 35);
        ages.put("David", 25); // Another person with age 25

        // Check if a specific value exists
        int valueToCheck = 25;
        boolean contains25 = ages.containsValue(valueToCheck);

        System.out.println("Does the map contain the value " + valueToCheck + "? " + contains25);

        valueToCheck = 40;
        boolean contains40 = ages.containsValue(valueToCheck);
        System.out.println("Does the map contain the value " + valueToCheck + "? " + contains40);
    }
}
```
Examinons les nouvelles parties de ce code :
- import java.util.HashMap; : Cette ligne importe la classe HashMap, que nous devons utiliser.
- HashMap<String, Integer> ages = new HashMap<>(); : Cette ligne crée une nouvelle HashMap où les clés sont des String (comme des noms) et les valeurs sont des Integer (comme des âges).
- ages.put("Alice", 30); et les lignes similaires : Ces lignes ajoutent des paires clé-valeur à la HashMap.
- int valueToCheck = 25; : Cela déclare une variable entière valueToCheck et lui assigne la valeur 25.
- boolean contains25 = ages.containsValue(valueToCheck); : C'est ici que nous utilisons la méthode containsValue(). Elle vérifie si la valeur stockée dans valueToCheck (qui est 25) existe quelque part dans les valeurs de la carte ages. Le résultat (true ou false) est stocké dans la variable booléenne contains25.
- System.out.println(...) : Ces lignes affichent les résultats dans la console.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme dans le terminal :
```
javac HelloJava.java
```
S'il n'y a pas d'erreurs, un fichier HelloJava.class sera créé.
Exécutez le programme compilé :
```
java HelloJava
```
Vous devriez voir un affichage indiquant si les valeurs 25 et 40 sont présentes dans la carte.
```
Does the map contain the value 25? true
Does the map contain the value 40? false
```

Cela démontre à quel point il est facile de vérifier l'existence d'une valeur dans une HashMap en utilisant la méthode containsValue().

Parcourir manuellement les valeurs

Dans l'étape précédente, nous avons utilisé la méthode intégrée containsValue() pour vérifier l'existence d'une valeur. Bien que ce soit la méthode la plus efficace, il est également utile de comprendre comment on pourrait vérifier manuellement l'existence d'une valeur en parcourant toutes les valeurs de la HashMap. Ce processus consiste à obtenir une collection de toutes les valeurs, puis à les parcourir une par une.

La HashMap de Java fournit une méthode appelée values() qui renvoie une vue Collection des valeurs contenues dans la carte. Nous pouvons ensuite parcourir cette Collection à l'aide d'une boucle.

Modifions notre programme pour vérifier manuellement si la valeur 25 existe en parcourant les valeurs.

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

Remplacez le code existant par le suivant :

import java.util.HashMap;
import java.util.Collection;

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

        // Add some key-value pairs
        ages.put("Alice", 30);
        ages.put("Bob", 25);
        ages.put("Charlie", 35);
        ages.put("David", 25); // Another person with age 25

        // Get a collection of all values
        Collection<Integer> allAges = ages.values();

        // Manually check if a specific value exists by looping
        int valueToCheck = 25;
        boolean foundManually = false;

        for (Integer age : allAges) {
            if (age.equals(valueToCheck)) {
                foundManually = true;
                break; // Exit the loop once the value is found
            }
        }

        System.out.println("Does the map contain the value " + valueToCheck + " (manual check)? " + foundManually);

        valueToCheck = 40;
        foundManually = false; // Reset for the next check

        for (Integer age : allAges) {
             if (age.equals(valueToCheck)) {
                foundManually = true;
                break;
            }
        }
         System.out.println("Does the map contain the value " + valueToCheck + " (manual check)? " + foundManually);
    }
}

Voici ce qui est nouveau ou a été modifié :

- `import java.util.Collection;` : Nous importons l'interface `Collection` car `ages.values()` renvoie une `Collection`.
- `Collection<Integer> allAges = ages.values();` : Cette ligne obtient une `Collection` contenant toutes les valeurs entières (âges) de notre carte `ages`.
- `for (Integer age : allAges)` : Il s'agit d'une boucle `for` améliorée (également connue sous le nom de boucle `for-each`) qui parcourt chaque élément `Integer` de la collection `allAges`. À chaque itération, la valeur actuelle est assignée à la variable `age`.
- `if (age.equals(valueToCheck))` : À l'intérieur de la boucle, nous comparons l'`age` actuel avec la `valueToCheck`. Nous utilisons `equals()` pour comparer des objets (comme `Integer`), ce qui est généralement plus sûr que d'utiliser `==` pour les objets.
- `foundManually = true;` : Si une correspondance est trouvée, nous définissons `foundManually` sur `true`.
- `break;` : Cette instruction quitte immédiatement la boucle une fois que la valeur est trouvée, rendant la vérification plus efficace.

Enregistrez le fichier.
Compilez le programme :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```

La sortie devrait être la même que dans l'étape précédente, confirmant que notre vérification manuelle fonctionne correctement.

```plaintext
Does the map contain the value 25 (manual check)? true
Does the map contain the value 40 (manual check)? false
```

Bien que le parcours manuel fonctionne, l'utilisation de containsValue() est généralement préférée car elle est plus concise et souvent optimisée pour les performances dans la bibliothèque Java. Cependant, comprendre comment parcourir les valeurs est une compétence fondamentale qui sera utile dans de nombreux autres scénarios.

Gérer les valeurs null

En Java, null est une valeur spéciale qui signifie "aucun objet". Il est important de comprendre comment une HashMap gère les valeurs null et comment containsValue() se comporte lorsqu'elle traite des valeurs null.

Une HashMap en Java peut stocker des valeurs null. Vous pouvez ajouter une association où la valeur est null.

Modifions notre programme pour inclure une valeur null et voir comment containsValue() fonctionne avec elle.

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

Remplacez le code existant par le suivant :

import java.util.HashMap;

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

        // Add some key-value pairs, including a null value
        ages.put("Alice", 30);
        ages.put("Bob", 25);
        ages.put("Charlie", null); // Charlie's age is unknown (null)
        ages.put("David", 25);

        // Check if a specific value exists, including null
        int valueToCheck = 25;
        boolean contains25 = ages.containsValue(valueToCheck);
        System.out.println("Does the map contain the value " + valueToCheck + "? " + contains25);

        Integer nullValue = null;
        boolean containsNull = ages.containsValue(nullValue);
        System.out.println("Does the map contain the value null? " + containsNull);

        valueToCheck = 40;
        boolean contains40 = ages.containsValue(valueToCheck);
        System.out.println("Does the map contain the value " + valueToCheck + "? " + contains40);
    }
}

Voici le changement clé :

- `ages.put("Charlie", null);` : Nous avons ajouté une association où la clé "Charlie" est associée à une valeur `null`.
- `Integer nullValue = null;` : Nous créons une variable `Integer` et lui assignons la valeur `null`.
- `boolean containsNull = ages.containsValue(nullValue);` : Nous utilisons `containsValue()` pour vérifier si la carte contient la valeur `null`.

Enregistrez le fichier.
Compilez le programme :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```

Observez la sortie, en particulier la ligne vérifiant la présence de null.

```plaintext
Does the map contain the value 25? true
Does the map contain the value null? true
Does the map contain the value 40? false
```

Comme vous pouvez le voir, containsValue() identifie correctement que la HashMap contient la valeur null car nous l'avons explicitement ajoutée. Cela confirme que la HashMap peut stocker des valeurs null et que containsValue() peut être utilisée pour vérifier leur présence.

La gestion des valeurs null est un aspect important de la programmation en Java. Soyez toujours attentif au fait que vos structures de données puissent contenir des valeurs null et à la façon dont votre code se comportera dans de tels cas.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si une HashMap contient une valeur spécifique en Java. La méthode principale étudiée était containsValue(), qui offre un moyen simple de déterminer la présence d'une valeur dans la carte. Nous avons vu comment utiliser cette méthode avec un exemple simple, en montrant sa valeur de retour en fonction de l'existence de la valeur cible dans la carte.

Nous avons également exploré des méthodes alternatives pour vérifier l'existence d'une valeur, comme l'itération manuelle à travers les valeurs de la carte. De plus, le laboratoire a couvert la gestion des valeurs null lors de la vérification de leur présence dans la carte, assurant ainsi une compréhension complète de la vérification des valeurs dans une HashMap.