Wie man prüft, ob ein Stack in Java leer ist

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob ein Stack in Java leer ist. Wir werden verschiedene Methoden untersuchen, um dies zu erreichen, einschließlich der Standardmethode isEmpty() und der size()-Methode. Sie werden auch lernen, wie Sie den Fall eines Null-Stacks behandeln.

Durch praktische Beispiele gewinnen Sie praktische Erfahrung in der Anwendung dieser Techniken, um die Leerheit eines Java-Stacks zu bestimmen, was eine grundlegende Operation beim Arbeiten mit dieser Datenstruktur ist.

Skills Graph

Verwendung von isEmpty() zur Überprüfung eines Stacks

In diesem Schritt lernen wir, wie man prüft, ob ein Stack in Java leer ist, indem man die isEmpty()-Methode verwendet. Die Stack-Klasse ist Teil des Java Collections Frameworks und repräsentiert einen Stapel von Objekten nach dem Prinzip "Last-In, First-Out" (LIFO). Das Prüfen, ob ein Stapel leer ist, ist eine häufige Operation beim Arbeiten mit Stapeln, beispielsweise bevor man versucht, ein Element zu entfernen.

Die isEmpty()-Methode ist eine einfache und effiziente Möglichkeit, zu bestimmen, ob eine Sammlung, einschließlich eines Stacks, Elemente enthält. Sie gibt true zurück, wenn die Sammlung leer ist (keine Elemente enthält), und false sonst.

Lassen Sie uns ein einfaches Java-Programm erstellen, um die isEmpty()-Methode zu demonstrieren.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.

2. Ersetzen Sie den gesamten Inhalt der Datei durch folgenden Code:

   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);
       }
   }

   Schauen wir uns die neuen Teile dieses Codes an:

   • import java.util.Stack;: Diese Zeile importiert die Stack-Klasse, so dass sie in unserem Programm verwendet werden kann.
   • Stack<String> stack = new Stack<>();: Diese Zeile erstellt einen neuen leeren Stack, der String-Objekte aufnehmen kann.
   • stack.isEmpty();: Dies ist die Methode, auf die wir uns konzentrieren. Sie prüft, ob das stack-Objekt leer ist.
   • stack.push("...");: Diese Methode fügt ein Element oben auf den Stapel hinzu.

3. Speichern Sie die Datei (Strg+S oder Cmd+S).

4. Jetzt lassen wir unser modifiziertes Programm kompilieren. Stellen Sie im Terminal sicher, dass Sie sich im Verzeichnis ~/project befinden. Führen Sie dann aus:

   javac HelloJava.java

   Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe.

5. Schließlich lassen wir unser Programm ausführen:

   java HelloJava

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Is the stack empty before pushing elements? true
   Is the stack empty after pushing elements? false

   Diese Ausgabe bestätigt, dass die isEmpty()-Methode den Zustand des Stapels vor und nach dem Hinzufügen von Elementen korrekt gemeldet hat.

Überprüfung mit der size()-Methode

Im vorherigen Schritt haben wir die isEmpty()-Methode verwendet, um zu prüfen, ob ein Stapel leer ist. Eine weitere nützliche Methode für Sammlungen, einschließlich Stack, ist die size()-Methode. Die size()-Methode gibt die Anzahl der Elemente zurück, die derzeit in der Sammlung enthalten sind. Wir können diese Methode verwenden, um zu prüfen, ob ein Stapel leer ist, indem wir überprüfen, ob seine Größe 0 ist.

Während isEmpty() im Allgemeinen bevorzugt wird, wenn man einfach prüfen möchte, ob eine Sammlung leer ist, da es manchmal effizienter sein kann, erreicht das Prüfen, ob size() == 0, dasselbe Ergebnis. Es ist gut, sich beider Methoden bewusst zu sein.

Lassen Sie uns unser Programm ändern, um die size()-Methode zur Prüfung auf Leerheit zu verwenden.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

2. Ändern Sie den Code, um size() == 0 anstelle von isEmpty() zu verwenden:

   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);
       }
   }

   Beachten Sie die Änderungen:

   • Wir haben stack.isEmpty() durch stack.size() == 0 ersetzt, um auf Leerheit zu prüfen.
   • Wir haben auch eine Zeile hinzugefügt, um die tatsächliche Größe des Stapels nach dem Hinzufügen von Elementen mit stack.size() auszugeben.

3. Speichern Sie die Datei (Strg+S oder Cmd+S).

4. Kompilieren Sie das geänderte Programm im Terminal:

   javac HelloJava.java

   Wiederum bedeutet die fehlende Ausgabe, dass die Kompilierung erfolgreich war.

5. Führen Sie das Programm aus:

   java HelloJava

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Is the stack empty before pushing elements? true
   Size of the stack after pushing elements: 3
   Is the stack empty after pushing elements? false

   Diese Ausgabe zeigt, dass das Prüfen von stack.size() == 0 korrekt erkennt, ob ein Stapel leer ist, und dass stack.size() die Anzahl der Elemente zurückgibt.

Test mit einem Null-Stack

In den vorherigen Schritten haben wir gelernt, wie man prüft, ob ein Stack leer ist, indem man isEmpty() und size() verwendet. Es ist auch wichtig zu verstehen, was passiert, wenn das Stack-Objekt selbst null ist. In Java bedeutet null, dass eine Variable auf kein Objekt verweist. Wenn man versucht, eine Methode auf einem null-Objekt aufzurufen, führt dies zu einer NullPointerException, die ein häufiger Laufzeitfehler ist.

Lassen Sie uns dies in Aktion sehen und lernen, wie man damit umgeht.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

2. Ändern Sie den Code, um den Stack auf null zu setzen und dann zu versuchen, zu prüfen, ob er leer ist:

   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.");
           }
       }
   }

   Hier ist, was neu ist:

   • stack = null;: Diese Zeile lässt die stack-Variable auf null verweisen. Das Stack-Objekt, das wir zuvor erstellt haben, ist über diese Variable nicht mehr zugänglich.
   • try { ... } catch (NullPointerException e) { ... }: Dies ist ein try-catch-Block. Er wird verwendet, um potenzielle Fehler (Ausnahmen) zu behandeln, die während der Ausführung des Codes im try-Block auftreten können. Wenn eine NullPointerException auftritt, wird der Code im catch-Block ausgeführt.

3. Speichern Sie die Datei (Strg+S oder Cmd+S).

4. Kompilieren Sie das Programm im Terminal:

   javac HelloJava.java

   Die Kompilierung sollte erfolgreich sein.

5. Führen Sie das Programm aus:

   java HelloJava

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Caught a NullPointerException! The stack object is null.
   Caught a NullPointerException! Cannot get size of a null stack.

   Diese Ausgabe zeigt, dass das Versuch, isEmpty() oder size() auf einer null-stack-Variable aufzurufen, zu einer NullPointerException führt, und unsere try-catch-Blöcke haben diese Ausnahmen erfolgreich behandelt.

Dies zeigt, warum es von entscheidender Bedeutung ist, sicherzustellen, dass ein Objekt nicht null ist, bevor man Methoden auf ihm aufruft. Sie können prüfen, ob ein Objekt null ist, indem Sie eine einfache Bedingung verwenden: if (stack != null) { ... }.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob ein Stack in Java leer ist. Wir haben die primäre Methode für diesen Zweck, isEmpty(), untersucht, die Teil des Java Collections Frameworks ist. Wir haben gesehen, wie man isEmpty() verwendet, um festzustellen, ob ein Stapel Elemente enthält. Die Methode gibt true zurück, wenn der Stapel leer ist, und false sonst.

Wir haben die Verwendung von isEmpty() demonstriert, indem wir einen neuen Stack erstellt, seinen Leerzustand vor und nach dem Hinzufügen von Elementen geprüft und die Ergebnisse ausgegeben haben. Diese praktische Übung hat unser Verständnis davon festigt, wie man die isEmpty()-Methode effektiv zur Prüfung auf Leerheit von Stapeln in Java-Programmen einsetzen kann.