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.

Verwenden Sie isEmpty() zur Stack-Prüfung

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.

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

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.

Speichern Sie die Datei (Strg+S oder Cmd+S).
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.
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.

Prü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.

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

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

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Wiederum bedeutet die fehlende Ausgabe, dass die Kompilierung erfolgreich war.
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.

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

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

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Die Kompilierung sollte erfolgreich sein.
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.