Wie man prüft, ob eine Queue in Java leer ist

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob eine Queue in Java leer ist. Dies ist eine entscheidende Fähigkeit, um Fehler beim Arbeiten mit Queues zu vermeiden.

Wir werden die primäre Methode für diese Prüfung, isEmpty(), untersuchen und auch sehen, wie Sie den Zustand der Queue mithilfe der size()-Methode überprüfen können. Darüber hinaus werden wir behandeln, wie Sie Szenarien behandeln können, in denen die Queue möglicherweise null ist. Anhand von praktischen Beispielen gewinnen Sie praktische Erfahrung bei der Bestimmung der Leerheit einer Java-Queue.

Verwenden Sie isEmpty() für die Queue-Prüfung

In diesem Schritt werden wir untersuchen, wie Sie prüfen können, ob eine Queue in Java leer ist, indem Sie die isEmpty()-Methode verwenden. Dies ist eine grundlegende Operation beim Arbeiten mit Sammlungen (Collections), da es uns ermöglicht, Fehler zu vermeiden, die auftreten können, wenn versucht wird, Elemente aus einer leeren Queue abzurufen.

Zunächst erstellen wir ein einfaches Java-Programm, das die Verwendung von isEmpty() demonstriert.

1. Öffnen Sie die WebIDE und navigieren Sie im Dateiexplorer links zum Verzeichnis ~/project.

2. Klicken Sie mit der rechten Maustaste in den leeren Bereich des Dateiexplorers, wählen Sie "Neue Datei" und benennen Sie sie QueueCheck.java.

3. Öffnen Sie die Datei QueueCheck.java im Editor.

4. Kopieren und fügen Sie den folgenden Code in den Editor ein:

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

   Schauen wir uns schnell die neuen Teile dieses Codes an:

   • import java.util.LinkedList; und import java.util.Queue;: Diese Zeilen importieren die notwendigen Klassen, um mit Queues zu arbeiten. Wir verwenden LinkedList als konkrete Implementierung des Queue-Interfaces.
   • Queue<String> myQueue = new LinkedList<>();: Diese Zeile erstellt ein neues Queue-Objekt namens myQueue, das String-Elemente enthalten kann.
   • myQueue.isEmpty(): Dies ist die Methode, auf die wir uns konzentrieren. Sie gibt true zurück, wenn die Queue keine Elemente enthält, und false sonst.
   • myQueue.add("Element 1");: Dies fügt ein Element an das Ende der Queue hinzu.

5. Speichern Sie die Datei QueueCheck.java (Strg+S oder Cmd+S).

6. Öffnen Sie das Terminal unten in der WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Wenn nicht, geben Sie cd ~/project ein und drücken Sie die Eingabetaste.

7. Kompilieren Sie das Java-Programm, indem Sie den folgenden Befehl eingeben und die Eingabetaste drücken:

   javac QueueCheck.java
   

   Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe. Eine Datei QueueCheck.class wird im Verzeichnis ~/project erstellt.

8. Führen Sie das kompilierte Java-Programm aus, indem Sie den folgenden Befehl eingeben und die Eingabetaste drücken:

   java QueueCheck
   

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Is the queue empty before adding elements? true
   Is the queue empty after adding elements? false
   

Diese Ausgabe bestätigt, dass die isEmpty()-Methode den Zustand der Queue vor und nach dem Hinzufügen von Elementen korrekt gemeldet hat. Die Verwendung von isEmpty() ist die empfohlene Methode, um zu prüfen, ob eine Sammlung leer ist, da sie im Allgemeinen effizienter ist als die Prüfung, ob die Größe null ist, insbesondere bei bestimmten Sammlungsimplementierungen.

Mit der size()-Methode überprüfen

Im vorherigen Schritt haben wir gelernt, wie man die isEmpty()-Methode verwendet, um zu prüfen, ob eine Queue leer ist. Eine andere Möglichkeit, festzustellen, ob eine Sammlung (Collection) leer ist, besteht darin, ihre Größe zu überprüfen. Die size()-Methode gibt die Anzahl der Elemente in der Sammlung zurück. Wenn die Größe 0 ist, ist die Sammlung leer.

Während isEmpty() aufgrund möglicher Leistungsvorteile bei bestimmten Sammlungsarten im Allgemeinen zur Prüfung auf Leerheit bevorzugt wird, ist es auch wichtig, zu verstehen, wie man size() verwendet.

Lassen Sie uns unser QueueCheck.java-Programm ändern, um auch die size()-Methode zu verwenden.

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

2. Ändern Sie die main-Methode, um Prüfungen mit der size()-Methode einzubeziehen. Ersetzen Sie die vorhandene main-Methode durch den folgenden Code:

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

   In diesem aktualisierten Code haben wir Zeilen hinzugefügt, um zu prüfen, ob die size() der Queue gleich 0 ist, sowohl vor als auch nach dem Hinzufügen von Elementen. Wir geben auch die endgültige Größe der Queue aus.

3. Speichern Sie die geänderte Datei QueueCheck.java.

4. Öffnen Sie das Terminal und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

5. Kompilieren Sie das aktualisierte Java-Programm:

   javac QueueCheck.java
   

6. Führen Sie das kompilierte Programm aus:

   java QueueCheck
   

   Sie sollten jetzt eine Ausgabe ähnlich der folgenden sehen:

   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
   

Wie Sie sehen können, liefern sowohl isEmpty() als auch die Prüfung, ob size() == 0, dasselbe Ergebnis bei der Bestimmung, ob die Queue leer ist. Die size()-Methode ist auch nützlich, um genau zu wissen, wie viele Elemente derzeit in der Queue sind.

Null-Queues behandeln

In den vorherigen Schritten haben wir mit einem ordnungsgemäß initialisierten Queue-Objekt gearbeitet. In der Praxis der Programmierung kann es jedoch vorkommen, dass ein Verweis auf eine Queue (oder ein beliebiges anderes Objekt) null ist. Wenn man versucht, eine Methode auf einem null-Objekt aufzurufen, wird eine NullPointerException ausgelöst, was ein häufiger Laufzeitfehler in Java ist.

Es ist von entscheidender Bedeutung, potenzielle null-Verweise zu behandeln, um diese Fehler zu vermeiden. Bevor Sie Methoden wie isEmpty() oder size() auf einer Queue aufrufen, sollten Sie immer prüfen, ob der Verweis auf die Queue selbst null ist.

Lassen Sie uns unser QueueCheck.java-Programm noch einmal ändern, um zu zeigen, wie man mit einer null-Queue umgeht.

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

2. Ändern Sie die main-Methode, um eine Prüfung auf eine null-Queue einzubeziehen. Ersetzen Sie die vorhandene main-Methode durch den folgenden Code:

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

   Wir haben den ursprünglichen Code, der auf myQueue operiert, in einen if (myQueue != null)-Block eingebettet. Dies stellt sicher, dass wir nur Methoden auf myQueue aufrufen, wenn es nicht null ist. Wir haben auch einen Abschnitt hinzugefügt, um die Prüfung einer Variablen zu demonstrieren, die explizit auf null gesetzt wurde.

3. Speichern Sie die geänderte Datei QueueCheck.java.

4. Öffnen Sie das Terminal und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

5. Kompilieren Sie das aktualisierte Java-Programm:

   javac QueueCheck.java
   

6. Führen Sie das kompilierte Programm aus:

   java QueueCheck
   

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   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.
   

Diese Ausgabe zeigt, dass unser Code sowohl den Fall, in dem die Queue initialisiert ist, als auch den Fall, in dem der Verweis auf die Queue null ist, korrekt behandelt und so eine NullPointerException vermeidet. Denken Sie immer daran, auf null zu prüfen, wenn Sie in Java mit Objektverweisen arbeiten, insbesondere wenn diese aus externen Quellen stammen oder das Ergebnis von Operationen sein können, die null zurückgeben können.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob eine Queue in Java leer ist. Wir haben uns hauptsächlich auf die Verwendung der isEmpty()-Methode konzentriert, die die Standard- und empfohlene Methode für diese Prüfung ist. Wir haben ein einfaches Java-Programm erstellt, um zu zeigen, dass isEmpty() true für eine leere Queue und false nach dem Hinzufügen von Elementen zurückgibt.

Darüber hinaus haben wir die size()-Methode als alternative Möglichkeit zur Prüfung auf Leerheit untersucht und festgestellt, dass eine Größe von 0 auf eine leere Queue hinweist. Schließlich haben wir die Wichtigkeit des Umgangs mit potenziellen NullPointerException besprochen, indem wir prüfen, ob ein Queue-Objekt null ist, bevor wir versuchen, Methoden auf ihm aufzurufen.