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.

Skills Graph

Utilisation de 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().

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.

2. 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.

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

4. 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.

5. 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érification 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.

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

2. 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().

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

4. Compilez le programme modifié dans le terminal :

   javac HelloJava.java

   Encore une fois, l'absence de sortie signifie que la compilation a réussi.

5. 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.

Test 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.

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

2. 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é.

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

4. Compilez le programme dans le terminal :

   javac HelloJava.java

   La compilation devrait réussir.

5. 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.