Comment vérifier si une pile est vide en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une Stack (pile) en Java est vide. Nous explorerons différentes méthodes pour y parvenir, y compris la méthode standard isEmpty() et la méthode size(). Vous apprendrez également à gérer le cas d'une pile nulle.

Grâce à des exemples pratiques, vous acquerrez une expérience concrète dans l'utilisation de ces techniques pour déterminer si une Stack Java est vide, ce qui est une opération fondamentale lorsqu'on travaille avec cette structure de données.

Utiliser isEmpty() pour vérifier une pile

Dans cette étape, nous apprendrons à vérifier si une Stack (pile) en Java est vide en utilisant la méthode isEmpty(). La classe Stack fait partie du Framework de collections Java et représente une pile d'objets de type dernier entré, premier sorti (Last-In, First-Out - LIFO). Vérifier si une pile est vide est une opération courante lorsqu'on travaille avec des piles, par exemple, avant d'essayer de supprimer un élément.

La méthode isEmpty() est un moyen simple et efficace de déterminer si une collection, y compris une Stack, contient des éléments. Elle retourne true si la collection est vide (ne contient aucun élément) et false dans le cas contraire.

Créons un simple programme Java pour démontrer la méthode isEmpty().

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.Stack;

public class HelloJava {
    public static void main(String[] args) {
        // Create a new Stack
        Stack<String> stack = new Stack<>();

        // Check if the stack is empty using isEmpty()
        boolean isEmptyBeforePush = stack.isEmpty();
        System.out.println("Is the stack empty before pushing elements? " + isEmptyBeforePush);

        // Push some elements onto the stack
        stack.push("Element 1");
        stack.push("Element 2");

        // Check if the stack is empty after pushing elements
        boolean isEmptyAfterPush = stack.isEmpty();
        System.out.println("Is the stack empty after pushing elements? " + isEmptyAfterPush);
    }
}

Examinons les nouvelles parties de ce code :

import java.util.Stack; : Cette ligne importe la classe Stack, la rendant disponible pour utilisation dans notre programme.
Stack<String> stack = new Stack<>(); : Cette ligne crée une nouvelle Stack vide capable de contenir des objets de type String.
stack.isEmpty(); : C'est la méthode sur laquelle nous nous concentrons. Elle vérifie si l'objet stack est vide.
stack.push("..."); : Cette méthode ajoute un élément au sommet de la pile.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, compilons notre programme modifié. Dans le terminal, assurez-vous d'être dans le répertoire ~/project. Ensuite, exécutez :
```
javac HelloJava.java
```
Si la compilation réussit, vous ne verrez aucun message de sortie.
Enfin, exécutons notre programme :
```
java HelloJava
```
Vous devriez voir une sortie similaire à ceci :
```
Is the stack empty before pushing elements? true
Is the stack empty after pushing elements? false
```
Cette sortie confirme que la méthode isEmpty() a correctement indiqué l'état de la pile avant et après l'ajout d'éléments.

Vérifier avec la méthode size()

Dans l'étape précédente, nous avons utilisé la méthode isEmpty() pour vérifier si une pile est vide. Une autre méthode utile pour les collections, y compris les Stack (piles), est la méthode size(). La méthode size() retourne le nombre d'éléments actuellement présents dans la collection. Nous pouvons utiliser cette méthode pour vérifier si une pile est vide en vérifiant si sa taille est égale à 0.

Bien que isEmpty() soit généralement préféré pour simplement vérifier si une collection est vide car il peut parfois être plus efficace, vérifier si size() == 0 aboutit au même résultat. Il est bon de connaître les deux méthodes.

Modifions notre programme pour utiliser la méthode size() pour vérifier si la pile est vide.

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

Modifiez le code pour utiliser size() == 0 au lieu de isEmpty() :

import java.util.Stack;

public class HelloJava {
    public static void main(String[] args) {
        // Create a new Stack
        Stack<String> stack = new Stack<>();

        // Check if the stack is empty using size()
        boolean isEmptyBeforePush = stack.size() == 0;
        System.out.println("Is the stack empty before pushing elements? " + isEmptyBeforePush);

        // Push some elements onto the stack
        stack.push("Element A");
        stack.push("Element B");
        stack.push("Element C");

        // Check the size of the stack after pushing elements
        int sizeAfterPush = stack.size();
        System.out.println("Size of the stack after pushing elements: " + sizeAfterPush);

        // Check if the stack is empty after pushing elements using size()
        boolean isEmptyAfterPush = stack.size() == 0;
        System.out.println("Is the stack empty after pushing elements? " + isEmptyAfterPush);
    }
}

Remarquez les modifications :

Nous avons remplacé stack.isEmpty() par stack.size() == 0 pour vérifier si la pile est vide.
Nous avons également ajouté une ligne pour afficher la taille réelle de la pile après avoir ajouté des éléments en utilisant stack.size().

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le terminal :
```
javac HelloJava.java
```
Encore une fois, l'absence de sortie signifie que la compilation a réussi.
Exécutez le programme :
```
java HelloJava
```
Vous devriez voir une sortie similaire à ceci :
```
Is the stack empty before pushing elements? true
Size of the stack after pushing elements: 3
Is the stack empty after pushing elements? false
```
Cette sortie montre que vérifier stack.size() == 0 identifie correctement une pile vide, et que stack.size() retourne le nombre d'éléments.

Tester avec une pile nulle

Dans les étapes précédentes, nous avons appris à vérifier si une Stack (pile) est vide en utilisant isEmpty() et size(). Il est également important de comprendre ce qui se passe si l'objet Stack lui-même est null. En Java, null signifie qu'une variable ne fait référence à aucun objet. Tenter d'appeler une méthode sur un objet null entraînera une NullPointerException, qui est une erreur d'exécution courante.

Voyons cela en action et apprenons à le gérer.

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

Modifiez le code pour définir la pile sur null puis essayez de vérifier si elle est vide :

import java.util.Stack;

public class HelloJava {
    public static void main(String[] args) {
        // Create a new Stack and then set it to null
        Stack<String> stack = new Stack<>();
        stack.push("Some Element"); // Add an element first
        stack = null; // Now set the stack variable to null

        // Try to check if the stack is empty using isEmpty()
        try {
            boolean isEmpty = stack.isEmpty(); // This line will cause an error
            System.out.println("Is the stack empty? " + isEmpty);
        } catch (NullPointerException e) {
            System.out.println("Caught a NullPointerException! The stack object is null.");
        }

        // Try to check the size using size()
        try {
             int size = stack.size(); // This line will also cause an error
             System.out.println("Size of the stack: " + size);
        } catch (NullPointerException e) {
             System.out.println("Caught a NullPointerException! Cannot get size of a null stack.");
        }
    }
}

Voici ce qui est nouveau :

stack = null; : Cette ligne fait pointer la variable stack sur null. L'objet Stack que nous avons créé précédemment n'est plus accessible via cette variable.
try { ... } catch (NullPointerException e) { ... } : Il s'agit d'un bloc try-catch. Il est utilisé pour gérer les erreurs potentielles (exceptions) qui pourraient se produire lors de l'exécution du code à l'intérieur du bloc try. Si une NullPointerException se produit, le code à l'intérieur du bloc catch sera exécuté.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme dans le terminal :
```
javac HelloJava.java
```
La compilation devrait réussir.
Exécutez le programme :
```
java HelloJava
```
Vous devriez voir une sortie similaire à ceci :
```
Caught a NullPointerException! The stack object is null.
Caught a NullPointerException! Cannot get size of a null stack.
```
Cette sortie montre que tenter d'appeler isEmpty() ou size() sur une variable de pile null entraîne une NullPointerException, et nos blocs try-catch ont réussi à gérer ces exceptions.

Cela démontre pourquoi il est crucial de s'assurer qu'un objet n'est pas null avant d'appeler des méthodes sur lui. Vous pouvez vérifier si un objet est null en utilisant une simple condition : if (stack != null) { ... }.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si une Stack (pile) en Java est vide. Nous avons exploré la méthode principale à cet effet, isEmpty(), qui fait partie du Framework de Collections Java. Nous avons vu comment utiliser isEmpty() pour déterminer si une pile contient des éléments, renvoyant true pour une pile vide et false dans le cas contraire.

Nous avons démontré l'utilisation de isEmpty() en créant une nouvelle Stack, en vérifiant son état de videté avant et après avoir ajouté des éléments, et en affichant les résultats. Cette pratique concrète a consolidé notre compréhension de l'utilisation efficace de la méthode isEmpty() pour vérifier la videté des piles dans les programmes Java.