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

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un élément spécifique existe dans une List Java. Nous explorerons différentes méthodes pour effectuer cette tâche courante lorsque vous travaillez avec des collections de données.

Vous apprendrez d'abord à utiliser la pratique méthode contains() fournie par l'interface List. Ensuite, vous comprendrez comment parcourir manuellement une liste pour vérifier la présence d'un élément, ce qui peut être utile dans certains scénarios. Enfin, nous aborderons la question de la gestion des éléments null dans votre liste lors de ces vérifications.

Skills Graph

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

Dans cette étape, nous apprendrons à vérifier si un élément spécifique existe dans une List Java en utilisant la méthode contains(). C'est une tâche courante lorsque l'on travaille avec des collections de données.

Tout d'abord, créons un nouveau fichier Java nommé ListContains.java dans votre répertoire ~/project. Vous pouvez le faire en cliquant avec le bouton droit dans l'explorateur de fichiers à gauche et en sélectionnant "Nouveau fichier", puis en tapant ListContains.java.

Maintenant, ouvrez le fichier ListContains.java dans l'éditeur et ajoutez le code suivant :

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

public class ListContains {

    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);
    }
}

Décortiquons ce code :

• import java.util.ArrayList; et import java.util.List; : Ces lignes importent les classes nécessaires pour travailler avec les List.
• List<String> fruits = new ArrayList<>(); : Cette ligne crée une nouvelle ArrayList, qui est un type de List capable de contenir des objets String.
• fruits.add("..."); : Ces lignes ajoutent des éléments (noms de fruits) à notre liste.
• fruits.contains("Banana"); : C'est le cœur de cette étape. La méthode contains() est appelée sur la liste fruits. Elle prend un argument, l'élément que nous voulons vérifier. Elle retourne true si l'élément est trouvé dans la liste, et false sinon.
• boolean hasBanana = ...; : Le résultat de contains() est stocké dans une variable booléenne (hasBanana ou hasGrape).
• System.out.println("..."); : Ces lignes affichent les résultats dans la console.

Enregistrez le fichier ListContains.java (Ctrl+S ou Cmd+S).

Maintenant, ouvrez le terminal en bas de l'IDE Web. Assurez-vous que vous êtes dans le répertoire ~/project. Sinon, tapez cd ~/project et appuyez sur Entrée.

Compilez le code Java en utilisant la commande javac :

javac ListContains.java

S'il n'y a pas d'erreurs, un fichier ListContains.class sera créé dans le répertoire ~/project.

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

java ListContains

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é si "Banana" et "Grape" étaient présents dans notre liste.

Parcourir une liste manuellement

Dans l'étape précédente, nous avons utilisé la méthode contains() pour vérifier la présence d'un élément. Bien que contains() soit pratique, il peut arriver que vous deviez examiner chaque élément d'une liste un par un. On appelle cela parcourir ou itérer une liste. Dans cette étape, nous apprendrons à le faire en utilisant une boucle for.

Ouvrez le fichier ListContains.java dans votre répertoire ~/project dans l'éditeur de l'IDE Web.

Nous allons modifier le code existant pour parcourir la liste fruits et afficher chaque élément. Remplacez la méthode main existante par le code suivant :

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

public class ListContains {

    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");

        // Loop through the list using a for loop
        System.out.println("Printing fruits in the list:");
        for (int i = 0; i < fruits.size(); i++) {
            String fruit = fruits.get(i);
            System.out.println(fruit);
        }
    }
}

Examinons les nouvelles parties :

• System.out.println("Printing fruits in the list:"); : Cette ligne affiche simplement un en-tête avant de commencer à lister les fruits.
• for (int i = 0; i < fruits.size(); i++) : C'est une boucle for standard.
  • int i = 0 : Nous initialisons une variable compteur i à 0. En programmation, nous commençons souvent à compter à partir de 0.
  • i < fruits.size() : La boucle continue tant que i est inférieur au nombre total d'éléments dans la liste fruits. fruits.size() nous donne le nombre d'éléments.
  • i++ : Après chaque exécution de la boucle, nous augmentons la valeur de i de 1.
• String fruit = fruits.get(i); : À l'intérieur de la boucle, fruits.get(i) récupère l'élément à la position actuelle i de la liste. Nous stockons cet élément dans une variable String appelée fruit.
• System.out.println(fruit); : Cette ligne affiche le fruit actuel dans la console.

Enregistrez le fichier ListContains.java.

Maintenant, compilez le code modifié dans le terminal :

javac ListContains.java

Si la compilation réussit, exécutez le programme :

java ListContains

Vous devriez voir la sortie suivante :

Printing fruits in the list:
Apple
Banana
Orange
Mango

Cela montre que notre boucle for a réussi à parcourir la liste et à afficher chaque fruit sur une nouvelle ligne. Parcourir manuellement une liste de cette manière vous donne plus de contrôle sur la façon dont vous traitez chaque élément, ce qui peut être utile pour des tâches plus complexes que simplement vérifier l'existence d'un élément.

Gérer les éléments nuls dans une liste

Dans le monde réel, les listes peuvent parfois contenir des valeurs "null", qui représentent l'absence de valeur. Si vous essayez d'effectuer des opérations sur une valeur nulle sans vérification, votre programme peut planter avec une NullPointerException. Dans cette étape, nous apprendrons à gérer les éléments nuls lors du parcours d'une liste.

Ouvrez le fichier ListContains.java dans votre répertoire ~/project dans l'éditeur de l'IDE Web.

Nous allons modifier le code pour ajouter un élément null à la liste, puis vérifier la nullité à l'intérieur de la boucle. Remplacez la méthode main existante par le code suivant :

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

public class ListContains {

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

        // Add some fruits to the list, including a null
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add(null); // Adding a null element
        fruits.add("Orange");
        fruits.add("Mango");

        // Loop through the list and handle null elements
        System.out.println("Printing fruits in the list (handling nulls):");
        for (int i = 0; i < fruits.size(); i++) {
            String fruit = fruits.get(i);

            // Check if the element is null before processing
            if (fruit != null) {
                System.out.println(fruit);
            } else {
                System.out.println("Found a null element");
            }
        }
    }
}

Voici ce que nous avons modifié :

• fruits.add(null); : Nous avons ajouté une valeur null à la liste.
• if (fruit != null) : À l'intérieur de la boucle, avant d'essayer d'afficher le fruit, nous ajoutons une instruction if pour vérifier que la variable fruit n'est pas nulle.
• System.out.println(fruit); : Cette ligne se trouve à l'intérieur du bloc if, donc elle ne s'exécutera que si fruit n'est pas nul.
• else { System.out.println("Found a null element"); } : Ce bloc else s'exécute si fruit est nul, affichant un message au lieu d'essayer d'afficher la valeur nulle elle-même.

Enregistrez le fichier ListContains.java.

Compilez le code modifié dans le terminal :

javac ListContains.java

Si la compilation réussit, exécutez le programme :

java ListContains

Vous devriez voir la sortie suivante :

Printing fruits in the list (handling nulls):
Apple
Banana
Found a null element
Orange
Mango

Comme vous pouvez le voir, le programme identifie et gère correctement l'élément nul sans planter. Vérifier la nullité est une pratique essentielle en programmation Java pour éviter les erreurs et rendre vos programmes plus robustes.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si une List Java contient un élément spécifique. Nous avons d'abord exploré la méthode la plus simple, en utilisant la méthode intégrée contains(), qui détermine efficacement la présence d'un élément et renvoie un résultat booléen.

Nous avons ensuite approfondi le parcours manuel de la liste pour effectuer la vérification, offrant une compréhension plus approfondie de fonctionnement interne de la méthode contains(). Enfin, nous avons abordé la considération importante de la gestion des éléments nuls dans la liste lors de ces vérifications, garantissant ainsi un code robuste et exempt d'erreurs.