Comment vérifier si une liste contient des éléments null en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une List Java contient des éléments null. Nous explorerons différentes méthodes pour y parvenir, en commençant par la méthode simple contains(). Vous apprendrez à utiliser contains(null) pour déterminer rapidement la présence d'une valeur nulle dans une liste.

Après la vérification initiale, le laboratoire vous guidera dans l'itération sur une liste pour vérifier manuellement chaque élément à la recherche de valeurs nulles. Cette approche offre plus de contrôle et permet de gérer les scénarios avec plusieurs éléments null, qui seront également abordés. À la fin de ce laboratoire, vous aurez une bonne compréhension des différentes techniques pour identifier les valeurs null dans les listes Java.

Skills Graph

Utilisation de contains() pour vérifier la présence de null

Dans cette étape, nous allons explorer comment vérifier la présence d'éléments null dans une List Java en utilisant la méthode contains(). Bien que contains() soit généralement utilisée pour vérifier la présence d'éléments spécifiques, elle peut également être utilisée pour savoir si une List contient null.

Tout d'abord, créons un nouveau fichier Java. Dans l'explorateur de fichiers à gauche, cliquez avec le bouton droit dans le répertoire ~/project, sélectionnez "Nouveau fichier" et nommez-le NullCheckList.java.

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

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

public class NullCheckList {

    public static void main(String[] args) {
        // Create a List and add some elements, including null
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add(null); // Adding a null element
        names.add("Bob");

        // Check if the list contains null using contains()
        boolean containsNull = names.contains(null);

        // Print the result
        System.out.println("Does the list contain null? " + containsNull);
    }
}

Décortiquons les nouvelles parties de ce code :

• import java.util.List; et import java.util.ArrayList; : Ces lignes importent les classes nécessaires pour travailler avec List et ArrayList.
• List<String> names = new ArrayList<>(); : Cela crée une nouvelle ArrayList capable de contenir des objets String. Nous la déclarons comme une List car List est une interface que ArrayList implémente.
• names.add(null); : Cette ligne ajoute explicitement une valeur null à notre liste.
• boolean containsNull = names.contains(null); : C'est le cœur de cette étape. Nous appelons la méthode contains() sur la liste names, en passant null comme argument. La méthode renvoie true si la liste contient null, et false sinon. Le résultat est stocké dans une variable booléenne containsNull.
• System.out.println("Does the list contain null? " + containsNull); : Cette ligne affiche le résultat de notre vérification dans la console.

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

Maintenant, compilons et exécutons le programme. Ouvrez le terminal en bas de l'IDE Web. Assurez-vous d'être dans le répertoire ~/project.

Compilez le code en utilisant javac :

javac NullCheckList.java

Si la compilation réussit (l'absence de message d'erreur signifie que la compilation a réussi), exécutez le code compilé en utilisant java :

java NullCheckList

Vous devriez voir un message indiquant si la liste contient null.

Parcourir la liste à la recherche de valeurs null

Dans l'étape précédente, nous avons utilisé la méthode contains() pour vérifier si une liste contient null. Bien que simple, cette méthode ne nous indique que si null est présent, pas où il se trouve ni combien de fois il apparaît. Une façon plus courante et flexible de gérer les éléments null dans une liste consiste à parcourir la liste à l'aide d'une boucle et à vérifier chaque élément individuellement.

Dans cette étape, nous allons modifier notre programme NullCheckList.java pour parcourir la liste et identifier la position (l'index) de tout élément null.

Ouvrez le fichier NullCheckList.java dans l'éditeur de l'IDE Web. Remplacez la méthode main existante par le code suivant :

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

public class NullCheckList {

    public static void main(String[] args) {
        // Create a List and add some elements, including null
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add(null); // Adding a null element
        names.add("Bob");
        names.add("Charlie");
        names.add(null); // Adding another null element

        System.out.println("Checking list for null elements:");

        // Loop through the list using a for loop
        for (int i = 0; i < names.size(); i++) {
            // Get the element at the current index
            String name = names.get(i);

            // Check if the element is null
            if (name == null) {
                System.out.println("Null found at index: " + i);
            }
        }
    }
}

Examinons les modifications :

• Nous avons ajouté un autre élément null à la liste pour démontrer la recherche de plusieurs valeurs null.
• for (int i = 0; i < names.size(); i++) : Il s'agit d'une boucle for standard qui itère depuis l'index 0 jusqu'à (mais sans inclure) la taille de la liste names. La variable i représente l'index actuel.
• String name = names.get(i); : À l'intérieur de la boucle, names.get(i) récupère l'élément à l'index actuel i et le stocke dans la variable name.
• if (name == null) : C'est la vérification cruciale. Nous utilisons l'opérateur d'égalité == pour comparer la variable name avec null. Si elles sont égales, cela signifie que l'élément à l'index actuel est null.
• System.out.println("Null found at index: " + i); : Si une valeur null est trouvée, cette ligne affiche un message indiquant l'index où elle a été trouvée.

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

Maintenant, compilez et exécutez le programme modifié depuis le terminal dans le répertoire ~/project :

javac NullCheckList.java

java NullCheckList

Vous devriez voir un message indiquant les indices où les éléments null ont été trouvés dans la liste.

Checking list for null elements:
Null found at index: 1
Null found at index: 4

Cette approche nous donne des informations plus détaillées sur les éléments null dans la liste, ce qui est souvent nécessaire pour les gérer correctement dans votre programme.

Gérer plusieurs éléments null

Dans l'étape précédente, nous avons réussi à parcourir une liste et à identifier les indices des éléments null. Maintenant, développons cette approche et montrons comment vous pouvez gérer ces éléments null. "Gérer" peut avoir différents sens selon la logique de votre programme, comme sauter l'élément null, le remplacer par une valeur par défaut ou effectuer une action spécifique.

Dans cette étape, nous allons modifier à nouveau notre programme NullCheckList.java. Cette fois, nous allons parcourir la liste et afficher un message différent pour les éléments non nuls par rapport aux éléments nuls.

Ouvrez le fichier NullCheckList.java dans l'éditeur de l'IDE Web. Remplacez la méthode main existante par le code suivant :

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

public class NullCheckList {

    public static void main(String[] args) {
        // Create a List and add some elements, including null
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add(null); // Adding a null element
        names.add("Bob");
        names.add("Charlie");
        names.add(null); // Adding another null element
        names.add("David");

        System.out.println("Processing list elements:");

        // Loop through the list using a for-each loop
        for (String name : names) {
            // Check if the element is null
            if (name == null) {
                System.out.println("Found a null element, skipping.");
            } else {
                // If the element is not null, process it
                System.out.println("Processing name: " + name);
            }
        }
    }
}

Examinons les modifications dans cette version :

• Nous avons ajouté un autre élément non nul ("David") à la liste.
• for (String name : names) : Il s'agit d'une boucle for améliorée (également connue sous le nom de boucle for-each). C'est un moyen pratique d'itérer sur les éléments d'une collection sans utiliser d'index. À chaque itération, la variable name contiendra l'élément actuel de la liste names.
• if (name == null) : Nous utilisons toujours l'opérateur == pour vérifier si l'élément actuel (name) est null.
• System.out.println("Found a null element, skipping."); : Si l'élément est null, nous affichons un message indiquant que nous le sautons. Dans une application réelle, vous pourriez effectuer une action différente ici, comme enregistrer le null ou assigner une valeur par défaut.
• else { System.out.println("Processing name: " + name); } : Si l'élément n'est pas null, nous entrons dans le bloc else et affichons un message indiquant que nous traitons le nom non nul.

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

Maintenant, compilez et exécutez le programme modifié depuis le terminal dans le répertoire ~/project :

javac NullCheckList.java

java NullCheckList

Vous devriez voir un affichage qui traite les noms non nuls et indique quand un élément null est rencontré.

Processing list elements:
Processing name: Alice
Found a null element, skipping.
Processing name: Bob
Processing name: Charlie
Found a null element, skipping.
Processing name: David

Cet exemple montre une façon de base de gérer les éléments null lors de l'itération. Selon vos besoins spécifiques, vous pourriez remplacer null par une chaîne de caractères par défaut, supprimer les éléments null de la liste ou effectuer d'autres opérations. L'essentiel est de vérifier la présence de null avant d'essayer d'utiliser l'élément, car tenter d'appeler des méthodes sur un objet null entraînera une NullPointerException.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une List Java contient des éléments null. Nous avons exploré l'utilisation de la méthode contains() en passant null comme argument, ce qui offre un moyen simple de déterminer la présence d'un seul élément null.

Nous avons créé un ArrayList exemple, ajouté à la fois des éléments valides et une valeur null, puis utilisé names.contains(null) pour effectuer la vérification. Le résultat a été affiché dans la console, démontrant l'efficacité de cette méthode pour une vérification de base des éléments null dans une liste.