Comment vérifier si une liste est vide en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier efficacement si une liste en Java est vide. Nous explorerons la méthode standard isEmpty(), vérifierons la taille de la liste à l'aide de la méthode size(), et comprendrons comment gérer les scénarios où la liste peut être nulle (null) pour écrire un code robuste et fiable.

Skills Graph

Utilisation de isEmpty() pour vérifier une liste

Dans cette étape, nous apprendrons à vérifier si une liste en Java est vide en utilisant la méthode isEmpty(). C'est une tâche courante en programmation, et isEmpty() offre un moyen clair et efficace de le faire.

Tout d'abord, créons un nouveau fichier Java nommé ListCheck.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 ListCheck.java.

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

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

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());
    }
}

Décortiquons ce code :

• import java.util.ArrayList; et import java.util.List; : Ces lignes importent les classes nécessaires pour travailler avec les listes.
• List<String> emptyList = new ArrayList<>(); : Cette ligne crée une nouvelle liste vide capable de contenir des objets String.
• List<String> populatedList = new ArrayList<>(); : Cette ligne crée une autre nouvelle liste.
• populatedList.add("Apple"); et populatedList.add("Banana"); : Ces lignes ajoutent des éléments à la populatedList.
• System.out.println("Is emptyList empty? " + emptyList.isEmpty()); : Cette ligne appelle la méthode isEmpty() sur emptyList. La méthode isEmpty() renvoie true si la liste n'a pas d'éléments et false sinon. Le résultat est ensuite affiché dans la console.
• System.out.println("Is populatedList empty? " + populatedList.isEmpty()); : Cette ligne fait la même chose pour populatedList.

Enregistrez le fichier ListCheck.java.

Maintenant, ouvrez le Terminal en bas de l'IDE Web et assurez-vous que vous êtes dans le répertoire ~/project. Vous pouvez utiliser la commande cd ~/project si nécessaire.

Compilez le code Java en utilisant la commande javac :

javac ListCheck.java

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

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

java ListCheck

Vous devriez voir une sortie similaire à celle-ci :

Is emptyList empty? true
Is populatedList empty? false

Cette sortie confirme que isEmpty() a correctement identifié la liste vide et la liste avec des éléments. Utiliser isEmpty() est la méthode préférée pour vérifier si une liste est vide en Java car elle est plus lisible et potentiellement plus efficace que de vérifier la taille.

Vérifier la taille d'une liste avec size()

Dans l'étape précédente, nous avons appris à vérifier si une liste est vide en utilisant la méthode isEmpty(). Bien que isEmpty() soit idéale pour vérifier si une liste contient des éléments, il peut arriver que vous ayez besoin de savoir exactement combien d'éléments elle contient. Pour cela, Java propose la méthode size().

Dans cette étape, nous allons modifier notre fichier ListCheck.java pour utiliser la méthode size() et voir comment elle fonctionne.

Ouvrez le fichier ListCheck.java dans l'éditeur de l'IDE Web s'il n'est pas déjà ouvert. Il devrait se trouver dans votre répertoire ~/project.

Maintenant, ajoutons quelques lignes à notre méthode main pour afficher la taille de nos listes. Ajoutez les lignes suivantes après les lignes où vous avez utilisé isEmpty() :

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

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());

        // Get and print the size of the lists using size()
        System.out.println("Size of emptyList: " + emptyList.size());
        System.out.println("Size of populatedList: " + populatedList.size());
    }
}

Nous avons ajouté deux nouvelles lignes :

• System.out.println("Size of emptyList: " + emptyList.size()); : Cette ligne appelle la méthode size() sur emptyList. La méthode size() renvoie le nombre d'éléments de la liste sous forme d'entier.
• System.out.println("Size of populatedList: " + populatedList.size()); : Cette ligne fait la même chose pour populatedList.

Enregistrez le fichier ListCheck.java.

Maintenant, revenez au Terminal dans le répertoire ~/project. Nous devons recompiler le code Java modifié :

javac ListCheck.java

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

java ListCheck

Vous devriez maintenant voir une sortie similaire à celle-ci :

Is emptyList empty? true
Is populatedList empty? false
Size of emptyList: 0
Size of populatedList: 2

Comme vous pouvez le voir, size() a correctement indiqué que emptyList contient 0 élément et que populatedList en contient 2.

Bien que vous puissiez vérifier si une liste est vide en vérifiant si sa taille est égale à 0 (list.size() == 0), il est généralement préférable d'utiliser isEmpty() pour plus de clarté et de lisibilité. Cependant, size() est essentielle lorsque vous avez besoin de connaître le nombre exact d'éléments dans une liste, par exemple, lors d'une boucle sur la liste ou pour effectuer des calculs basés sur le nombre d'éléments.

Gérer les listes nulles

Dans les étapes précédentes, nous avons travaillé avec des listes qui étaient soit vides, soit contenaient des éléments. Cependant, en programmation réelle, il est possible qu'une variable de liste soit null. Une référence null signifie que la variable ne pointe vers aucun objet en mémoire. Tenter d'appeler une méthode comme isEmpty() ou size() sur une liste null entraînera une NullPointerException, qui est une erreur courante en Java.

Dans cette étape, nous apprendrons à gérer en toute sécurité les listes null avant d'essayer de vérifier si elles sont vides ou d'obtenir leur taille.

Ouvrez le fichier ListCheck.java dans l'éditeur de l'IDE Web.

Ajoutons une nouvelle variable de liste et définissons-la sur null. Ensuite, nous allons montrer ce qui se passe lorsque vous essayez d'appeler des méthodes sur elle sans vérifier si elle est null. Modifiez votre méthode main pour inclure le code suivant :

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

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Create a null list
        List<String> nullList = null;

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());

        // Get and print the size of the lists using size()
        System.out.println("Size of emptyList: " + emptyList.size());
        System.out.println("Size of populatedList: " + populatedList.size());

        // --- This part will cause an error if uncommented ---
        // System.out.println("Is nullList empty? " + nullList.isEmpty()); // This line will cause a NullPointerException
        // System.out.println("Size of nullList: " + nullList.size());   // This line will also cause a NullPointerException
        // ----------------------------------------------------

        // Safely check for null before calling methods
        System.out.println("\nSafely checking for null:");
        if (nullList == null) {
            System.out.println("nullList is null.");
        } else {
            System.out.println("Is nullList empty? " + nullList.isEmpty());
            System.out.println("Size of nullList: " + nullList.size());
        }

        if (emptyList == null) {
             System.out.println("emptyList is null.");
        } else {
             System.out.println("Is emptyList empty? " + emptyList.isEmpty());
             System.out.println("Size of emptyList: " + emptyList.size());
        }
    }
}

Nous avons ajouté :

• List<String> nullList = null; : Cela déclare une variable de liste mais définit sa valeur sur null.
• Des lignes commentées qui causeraient une NullPointerException.
• Une instruction if : if (nullList == null). C'est la partie cruciale pour gérer les valeurs null. Nous vérifions si la variable nullList est null avant d'essayer d'appeler des méthodes sur elle. Si elle est null, nous affichons un message. Si elle n'est pas null, nous pouvons appeler en toute sécurité isEmpty() et size().
• Nous avons également ajouté une vérification similaire pour emptyList pour montrer que la condition if fonctionne correctement pour les listes non nulles également.

Enregistrez le fichier ListCheck.java.

Compilez le code modifié dans le Terminal :

javac ListCheck.java

Exécutez le programme :

java ListCheck

La sortie devrait ressembler à ceci :

Is emptyList empty? true
Is populatedList empty? false
Size of emptyList: 0
Size of populatedList: 2

Safely checking for null:
nullList is null.
Is emptyList empty? true
Size of emptyList: 0

Notez que nous avons réussi à vérifier si nullList était null et avons évité la NullPointerException. Nous avons également confirmé que la vérification fonctionne correctement pour emptyList.

N'oubliez jamais de vérifier si une liste (ou toute référence d'objet) peut être null avant d'appeler des méthodes sur elle. C'est une pratique fondamentale en Java pour éviter les erreurs de NullPointerException. Un modèle courant est if (myList != null && !myList.isEmpty()) pour vérifier si une liste n'est pas null et n'est pas vide en une seule condition.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si une liste en Java est vide. Nous avons commencé par explorer la méthode isEmpty(), qui offre un moyen simple et efficace de déterminer si une liste contient des éléments. Nous avons créé des listes d'exemple, à la fois vides et remplies, et utilisé isEmpty() pour vérifier leur état, en observant la sortie booléenne.

Nous avons également examiné comment utiliser la méthode size() pour vérifier si une liste est vide en comparant sa taille à zéro. Cette méthode renvoie le nombre d'éléments dans la liste, et une taille de 0 indique une liste vide. Enfin, nous avons abordé l'aspect crucial de la gestion des listes nulles avant d'essayer de vérifier leur vacuité, en montrant comment éviter la NullPointerException en ajoutant une vérification de nullité.