Comment vérifier si un Set contient un élément spécifique en Java

Introduction

Dans ce laboratoire, vous apprendrez à vérifier si un élément spécifique existe dans une collection en Java. Nous allons nous concentrer sur l'utilisation de la méthode contains(), qui est disponible pour tous les types de collections. Vous allez pratiquer l'utilisation de contains() avec différents types d'éléments et apprendre à gérer les éléments nuls. À la fin de ce laboratoire, vous serez capable de déterminer facilement la présence d'éléments dans les collections Java.

Utiliser contains() pour vérifier la présence d'un élément

Dans cette étape, nous allons explorer comment vérifier si un élément spécifique existe dans une collection en Java. Les collections sont des structures de données fondamentales utilisées pour regrouper plusieurs éléments en une seule unité. Java propose différents types de collections, comme les Listes (Lists), les Ensembles (Sets) et les Cartes (Maps).

Une tâche courante lorsqu'on travaille avec des collections consiste à déterminer si un élément particulier est présent. L'interface Collection de Java, qui est l'interface racine pour tous les types de collections, fournit une méthode pratique à cet effet : contains().

La méthode contains() prend un argument, l'élément que vous souhaitez vérifier, et renvoie une valeur booléenne : true si l'élément est trouvé dans la collection, et false sinon.

Créons un simple programme Java pour démontrer comment utiliser la méthode contains() avec un ArrayList, qui est un type courant de Liste.

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.ArrayList;
import java.util.List;

public class HelloJava {
    public static void main(String[] args) {
        // Create a List of strings
        List<String> fruits = new ArrayList<>();

        // Add some fruits to the list
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        fruits.add("Mango");

        // Check if the list contains "Banana"
        boolean hasBanana = fruits.contains("Banana");
        System.out.println("Does the list contain Banana? " + hasBanana);

        // Check if the list contains "Grape"
        boolean hasGrape = fruits.contains("Grape");
        System.out.println("Does the list contain Grape? " + hasGrape);
    }
}
```
Analysons ce nouveau code :
- import java.util.ArrayList; et import java.util.List; : Ces lignes importent les classes nécessaires pour travailler avec les Listes et les ArrayLists.
- List<String> fruits = new ArrayList<>(); : Cette ligne crée un nouveau ArrayList capable de contenir des objets String et l'assigne à une variable nommée fruits.
- fruits.add("Apple"); et les lignes similaires : Ces lignes ajoutent des éléments (des chaînes de caractères représentant des noms de fruits) à notre liste fruits.
- boolean hasBanana = fruits.contains("Banana"); : Cette ligne appelle la méthode contains() sur la liste fruits pour vérifier si la chaîne de caractères "Banana" est présente. Le résultat (true ou false) est stocké dans une variable booléenne hasBanana.
- System.out.println("Does the list contain Banana? " + hasBanana); : Cette ligne affiche le résultat de la vérification pour "Banana".
- boolean hasGrape = fruits.contains("Grape"); et la ligne println suivante : Ces lignes effectuent la même vérification pour "Grape", qui n'est pas dans notre liste.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le Terminal :
```
javac HelloJava.java
```

Exécutez le programme compilé :

java HelloJava

Vous devriez voir une sortie similaire à celle-ci :

Does the list contain Banana? true
Does the list contain Grape? false

Cette sortie confirme que la méthode contains() a correctement identifié que "Banana" est dans la liste et que "Grape" ne l'est pas.

Comprendre comment vérifier la présence d'éléments est une compétence fondamentale lorsqu'on travaille avec des collections en Java. Dans les étapes suivantes, nous explorerons plus en détail la méthode contains() et son comportement dans différents scénarios.

Tester avec différents types d'éléments

Dans l'étape précédente, nous avons utilisé la méthode contains() avec une List d'objets String. La méthode contains() est polyvalente et peut être utilisée avec des collections qui stockent différents types d'éléments, tels que des nombres, des objets personnalisés ou même d'autres collections.

Lorsque vous utilisez contains(), Java s'appuie sur la méthode equals() des objets dans la collection pour déterminer si l'élément recherché correspond. Pour les types primitifs (comme int, double, boolean), leurs classes d'emballage correspondantes (Integer, Double, Boolean) sont utilisées, et leurs méthodes equals() comparent les valeurs. Pour les objets, la méthode equals() par défaut vérifie si les deux références d'objet pointent vers le même emplacement mémoire. Cependant, de nombreuses classes (comme String, Integer, etc.) remplacent la méthode equals() pour comparer le contenu ou la valeur réelle des objets.

Modifions notre programme pour qu'il fonctionne avec une List d'objets Integer et voyons comment se comporte contains().

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

Remplacez le code actuel par le suivant :

import java.util.ArrayList;
import java.util.List;

public class HelloJava {
    public static void main(String[] args) {
        // Create a List of integers
        List<Integer> numbers = new ArrayList<>();

        // Add some numbers to the list
        numbers.add(10);
        numbers.add(25);
        numbers.add(5);
        numbers.add(50);

        // Check if the list contains 25
        boolean hasTwentyFive = numbers.contains(25);
        System.out.println("Does the list contain 25? " + hasTwentyFive);

        // Check if the list contains 100
        boolean hasOneHundred = numbers.contains(100);
        System.out.println("Does the list contain 100? " + hasOneHundred);

        // Check if the list contains the Integer object with value 5
        boolean hasFiveObject = numbers.contains(Integer.valueOf(5));
        System.out.println("Does the list contain Integer object with value 5? " + hasFiveObject);
    }
}

Dans ce code :

Nous créons une List qui contient spécifiquement des objets Integer : List<Integer> numbers = new ArrayList<>();.
Nous ajoutons des valeurs entières à la liste en utilisant numbers.add(). Java convertit automatiquement les valeurs int primitives (10, 25, 5, 50) en objets Integer (cela s'appelle l'autoboxing).
Nous utilisons numbers.contains(25) et numbers.contains(100) pour vérifier la présence de valeurs entières. Encore une fois, Java effectue l'autoboxing des valeurs int primitives 25 et 100 en objets Integer avant d'effectuer la vérification.
Nous créons également explicitement un objet Integer en utilisant Integer.valueOf(5) et vérifions si la liste contient cet objet spécifique.

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

Exécutez le programme :

java HelloJava

Vous devriez voir une sortie similaire à celle-ci :

Does the list contain 25? true
Does the list contain 100? false
Does the list contain Integer object with value 5? true

Cela démontre que contains() fonctionne correctement avec les objets Integer, en comparant leurs valeurs. La méthode contains() utilise efficacement la méthode equals() des éléments de la collection et de l'élément recherché.

Dans l'étape suivante, nous explorerons un cas particulier : la gestion des éléments null avec la méthode contains().

Gérer les éléments null

En Java, les collections peuvent parfois contenir des éléments null. Il est important de comprendre comment se comporte la méthode contains() lorsqu'elle gère des valeurs null.

La bonne nouvelle est que la méthode contains() est conçue pour gérer les éléments null de manière élégante. Si une collection contient null, l'appel de contains(null) retournera true. Si la collection ne contient pas null, elle retournera false. Cela est cohérent avec la façon dont equals() est généralement implémentée pour null (la méthode equals(null) de tout objet devrait retourner false, mais null.equals(anyObject) lancerait une NullPointerException si elle n'était pas gérée en interne par l'implémentation de contains de la collection).

Modifions notre programme pour inclure et vérifier la présence d'éléments null.

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

Remplacez le code actuel par le suivant :

import java.util.ArrayList;
import java.util.List;

public class HelloJava {
    public static void main(String[] args) {
        // Create a List that can contain null
        List<String> mixedList = new ArrayList<>();

        // Add some elements, including null
        mixedList.add("First");
        mixedList.add(null); // Adding a null element
        mixedList.add("Second");
        mixedList.add(null); // Adding another null element
        mixedList.add("Third");

        // Check if the list contains null
        boolean hasNull = mixedList.contains(null);
        System.out.println("Does the list contain null? " + hasNull);

        // Check if the list contains a non-existent element
        boolean hasFourth = mixedList.contains("Fourth");
        System.out.println("Does the list contain Fourth? " + hasFourth);

        // Check if the list contains "First"
        boolean hasFirst = mixedList.contains("First");
        System.out.println("Does the list contain First? " + hasFirst);
    }
}

Dans ce code :

Nous créons une List appelée mixedList.
Nous ajoutons quelques éléments de type String et nous ajoutons également explicitement null en utilisant mixedList.add(null);.
Nous utilisons ensuite mixedList.contains(null) pour vérifier si la liste contient la valeur null.
Nous effectuons également des vérifications pour une chaîne non existante ("Fourth") et une chaîne existante ("First") pour voir les résultats parallèlement à la vérification de null.

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

Exécutez le programme :

java HelloJava

Vous devriez voir une sortie similaire à celle-ci :

Does the list contain null? true
Does the list contain Fourth? false
Does the list contain First? true

Cette sortie confirme que contains() identifie correctement la présence de null dans la liste. Il est important de savoir que les collections peuvent contenir null (en fonction du type de collection spécifique et de la façon dont elle est utilisée), et contains() offre un moyen fiable de vérifier cela.

Vous avez maintenant appris à utiliser la méthode contains() pour vérifier la présence d'éléments dans les collections Java, y compris différents types de données et le cas particulier de null. C'est un outil précieux pour travailler avec des collections dans vos programmes Java.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si une collection contient un élément spécifique en Java en utilisant la méthode contains(). Nous avons vu comment cette méthode, disponible via l'interface Collection, retourne un booléen indiquant la présence de l'élément. Nous avons démontré son utilisation avec une ArrayList et observé comment elle identifie correctement les éléments existants et non existants.

Nous avons également exploré le fonctionnement de la méthode contains() avec différents types de données et comment gérer les éléments null au sein d'une collection. Cette expérience pratique a fourni une compréhension concrète d'une opération fondamentale lors de la manipulation des collections Java.