Comment vérifier si une file d'attente (Queue) est vide en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une Queue en Java est vide. Cette compétence est essentielle pour éviter les erreurs lors de la manipulation des files d'attente (queues).

Nous allons explorer la méthode principale pour effectuer cette vérification, isEmpty(), et voir également comment vérifier l'état de la file d'attente à l'aide de la méthode size(). De plus, nous aborderons la gestion des scénarios où la file d'attente pourrait être nulle (null). Grâce à des exemples pratiques, vous acquerrez une expérience concrète pour déterminer si une file d'attente Java est vide.

Utilisez isEmpty() pour vérifier une file d'attente (Queue)

Dans cette étape, nous allons explorer comment vérifier si une Queue en Java est vide en utilisant la méthode isEmpty(). Il s'agit d'une opération fondamentale lors de la manipulation de collections, car elle nous permet d'éviter les erreurs qui pourraient survenir lors de la tentative d'accès à des éléments dans une file d'attente vide.

Tout d'abord, créons un simple programme Java qui démontre l'utilisation de isEmpty().

Ouvrez l'WebIDE et accédez au répertoire ~/project dans l'Explorateur de fichiers à gauche.
Cliquez avec le bouton droit dans l'espace vide de l'Explorateur de fichiers, sélectionnez "Nouveau fichier" et nommez - le QueueCheck.java.
Ouvrez le fichier QueueCheck.java dans l'éditeur.

Copiez et collez le code suivant dans l'éditeur :

import java.util.LinkedList;
import java.util.Queue;

public class QueueCheck {

    public static void main(String[] args) {
        // Create a Queue using LinkedList
        Queue<String> myQueue = new LinkedList<>();

        // Check if the queue is empty
        boolean isEmptyBeforeAdd = myQueue.isEmpty();
        System.out.println("Is the queue empty before adding elements? " + isEmptyBeforeAdd);

        // Add some elements to the queue
        myQueue.add("Element 1");
        myQueue.add("Element 2");

        // Check if the queue is empty again
        boolean isEmptyAfterAdd = myQueue.isEmpty();
        System.out.println("Is the queue empty after adding elements? " + isEmptyAfterAdd);
    }
}

Passons rapidement en revue les nouvelles parties de ce code :

import java.util.LinkedList; et import java.util.Queue; : Ces lignes importent les classes nécessaires pour travailler avec les files d'attente (Queues). Nous utilisons LinkedList comme implémentation concrète de l'interface Queue.
Queue<String> myQueue = new LinkedList<>(); : Cette ligne crée un nouvel objet Queue nommé myQueue qui peut contenir des éléments de type String.
myQueue.isEmpty() : C'est la méthode sur laquelle nous nous concentrons. Elle retourne true si la file d'attente ne contient aucun élément, et false sinon.
myQueue.add("Element 1"); : Cela ajoute un élément à la fin de la file d'attente.

Enregistrez le fichier QueueCheck.java (Ctrl+S ou Cmd+S).
Ouvrez le Terminal en bas de l'WebIDE. Assurez - vous que vous êtes dans le répertoire ~/project. Sinon, tapez cd ~/project et appuyez sur Entrée.
Compilez le programme Java en tapant la commande suivante et en appuyant sur Entrée :
```
javac QueueCheck.java
```
Si la compilation réussit, vous ne verrez aucun message de sortie. Un fichier QueueCheck.class sera créé dans le répertoire ~/project.
Exécutez le programme Java compilé en tapant la commande suivante et en appuyant sur Entrée :
```
java QueueCheck
```
Vous devriez voir une sortie similaire à ceci :
```
Is the queue empty before adding elements? true
Is the queue empty after adding elements? false
```

Cette sortie confirme que la méthode isEmpty() a correctement indiqué l'état de la file d'attente avant et après l'ajout d'éléments. L'utilisation de isEmpty() est la méthode recommandée pour vérifier si une collection est vide, car elle est généralement plus efficace que de vérifier si la taille est égale à zéro, en particulier pour certaines implémentations de collections.

Vérification avec la méthode size()

Dans l'étape précédente, nous avons appris à utiliser la méthode isEmpty() pour vérifier si une file d'attente (queue) est vide. Une autre façon de déterminer si une collection est vide consiste à vérifier sa taille. La méthode size() retourne le nombre d'éléments dans la collection. Si la taille est égale à 0, la collection est vide.

Bien que isEmpty() soit généralement préférée pour vérifier l'absence d'éléments en raison de bénéfices potentiels en termes de performances avec certains types de collections, il est également important de savoir utiliser size().

Modifions notre programme QueueCheck.java pour utiliser également la méthode size().

Ouvrez le fichier QueueCheck.java dans l'éditeur de l'WebIDE.

Modifiez la méthode main pour inclure des vérifications utilisant la méthode size(). Remplacez la méthode main existante par le code suivant :

import java.util.LinkedList;
import java.util.Queue;

public class QueueCheck {

    public static void main(String[] args) {
        // Create a Queue using LinkedList
        Queue<String> myQueue = new LinkedList<>();

        // Check if the queue is empty using isEmpty()
        boolean isEmptyBeforeAdd = myQueue.isEmpty();
        System.out.println("Is the queue empty before adding elements (isEmpty())? " + isEmptyBeforeAdd);

        // Check if the queue is empty using size()
        boolean isEmptyBySizeBeforeAdd = (myQueue.size() == 0);
        System.out.println("Is the queue empty before adding elements (size() == 0)? " + isEmptyBySizeBeforeAdd);


        // Add some elements to the queue
        myQueue.add("Element 1");
        myQueue.add("Element 2");

        // Check if the queue is empty again using isEmpty()
        boolean isEmptyAfterAdd = myQueue.isEmpty();
        System.out.println("Is the queue empty after adding elements (isEmpty())? " + isEmptyAfterAdd);

        // Check if the queue is empty again using size()
        boolean isEmptyBySizeAfterAdd = (myQueue.size() == 0);
        System.out.println("Is the queue empty after adding elements (size() == 0)? " + isEmptyBySizeAfterAdd);

        // Print the size of the queue
        System.out.println("Current queue size: " + myQueue.size());
    }
}

Dans ce code mis à jour, nous avons ajouté des lignes pour vérifier si la size() de la file d'attente est égale à 0 avant et après avoir ajouté des éléments. Nous affichons également la taille finale de la file d'attente.

Enregistrez le fichier QueueCheck.java modifié.
Ouvrez le Terminal et assurez - vous que vous êtes dans le répertoire ~/project.
Compilez le programme Java mis à jour :
```
javac QueueCheck.java
```

Exécutez le programme compilé :

java QueueCheck

Vous devriez maintenant voir une sortie similaire à ceci :

Is the queue empty before adding elements (isEmpty())? true
Is the queue empty before adding elements (size() == 0)? true
Is the queue empty after adding elements (isEmpty())? false
Is the queue empty after adding elements (size() == 0)? false
Current queue size: 2

Comme vous pouvez le voir, tant isEmpty() que la vérification si size() == 0 donnent le même résultat pour déterminer si la file d'attente est vide. La méthode size() est également utile pour savoir exactement combien d'éléments se trouvent actuellement dans la file d'attente.

Gérer les files d'attente nulles (Queues nulles)

Dans les étapes précédentes, nous avons travaillé avec un objet Queue correctement initialisé. Cependant, dans la programmation réelle, il est possible de rencontrer des situations où une référence à une Queue (ou à tout objet) est null. Tenter d'appeler une méthode sur un objet null entraînera une NullPointerException, qui est une erreur d'exécution courante en Java.

Il est crucial de gérer les références null potentielles pour éviter ces erreurs. Avant d'appeler des méthodes telles que isEmpty() ou size() sur une Queue, vous devez toujours vérifier si la référence à la file d'attente elle - même est null.

Modifions encore une fois notre programme QueueCheck.java pour démontrer comment gérer une file d'attente null.

Ouvrez le fichier QueueCheck.java dans l'éditeur de l'WebIDE.

Modifiez la méthode main pour inclure une vérification d'une file d'attente null. Remplacez la méthode main existante par le code suivant :

import java.util.LinkedList;
import java.util.Queue;

public class QueueCheck {

    public static void main(String[] args) {
        // Create a Queue using LinkedList
        Queue<String> myQueue = new LinkedList<>();

        // Check if the queue is null before checking emptiness or size
        if (myQueue != null) {
            // Check if the queue is empty using isEmpty()
            boolean isEmptyBeforeAdd = myQueue.isEmpty();
            System.out.println("Is the queue empty before adding elements (isEmpty())? " + isEmptyBeforeAdd);

            // Check if the queue is empty using size()
            boolean isEmptyBySizeBeforeAdd = (myQueue.size() == 0);
            System.out.println("Is the queue empty before adding elements (size() == 0)? " + isEmptyBySizeBeforeAdd);


            // Add some elements to the queue
            myQueue.add("Element 1");
            myQueue.add("Element 2");

            // Check if the queue is empty again using isEmpty()
            boolean isEmptyAfterAdd = myQueue.isEmpty();
            System.out.println("Is the queue empty after adding elements (isEmpty())? " + isEmptyAfterAdd);

            // Check if the queue is empty again using size()
            boolean isEmptyBySizeAfterAdd = (myQueue.size() == 0);
            System.out.println("Is the queue empty after adding elements (size() == 0)? " + isEmptyBySizeAfterAdd);

            // Print the size of the queue
            System.out.println("Current queue size: " + myQueue.size());
        } else {
            System.out.println("The queue is null. Cannot perform operations.");
        }

        // Example with a null queue reference
        Queue<String> nullQueue = null;

        // Attempting to check isEmpty() or size() on nullQueue without a null check would cause a NullPointerException
        System.out.println("\nChecking a potentially null queue:");
        if (nullQueue != null) {
             boolean isNullQueueEmpty = nullQueue.isEmpty();
             System.out.println("Is the null queue empty? " + isNullQueueEmpty);
        } else {
             System.out.println("The null queue is indeed null. Handled correctly.");
        }
    }
}

Nous avons enveloppé le code original qui opère sur myQueue dans un bloc if (myQueue != null). Cela garantit que nous n'appelons des méthodes sur myQueue que si elle n'est pas null. Nous avons également ajouté une section pour démontrer la vérification d'une variable explicitement définie sur null.

Enregistrez le fichier QueueCheck.java modifié.
Ouvrez le Terminal et assurez - vous que vous êtes dans le répertoire ~/project.
Compilez le programme Java mis à jour :
```
javac QueueCheck.java
```

Exécutez le programme compilé :

java QueueCheck

Vous devriez voir une sortie similaire à ceci :

Is the queue empty before adding elements (isEmpty())? true
Is the queue empty before adding elements (size() == 0)? true
Is the queue empty after adding elements (isEmpty())? false
Is the queue empty after adding elements (size() == 0)? false
Current queue size: 2

Checking a potentially null queue:
The null queue is indeed null. Handled correctly.

Cette sortie montre que notre code gère correctement à la fois le cas où la file d'attente est initialisée et le cas où la référence à la file d'attente est null, évitant ainsi une NullPointerException. N'oubliez jamais de vérifier les références d'objets pour null en Java, surtout lorsqu'elles peuvent provenir de sources externes ou être le résultat d'opérations qui pourraient retourner null.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une Queue en Java est vide. Nous nous sommes principalement concentrés sur l'utilisation de la méthode isEmpty(), qui est la manière standard et recommandée pour effectuer cette vérification. Nous avons créé un simple programme Java pour démontrer comment isEmpty() retourne true pour une file d'attente vide et false après avoir ajouté des éléments.

De plus, nous avons exploré la méthode size() comme une alternative pour vérifier l'absence d'éléments, en notant qu'une taille de 0 indique une file d'attente vide. Enfin, nous avons discuté de l'importance de gérer les NullPointerException potentielles en vérifiant si un objet de file d'attente est null avant d'essayer d'appeler des méthodes sur celui - ci.