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

Einführung

In diesem Lab lernen Sie, wie Sie effektiv prüfen können, ob eine Liste in Java leer ist. Wir werden die Standardmethode isEmpty() untersuchen, die Größe der Liste mit size() überprüfen und verstehen, wie Sie potenzielle Szenarien mit einer null-Liste behandeln können, um robusten und zuverlässigen Code zu schreiben.

Skills Graph

Verwendung von isEmpty() zur Listenprüfung

In diesem Schritt lernen wir, wie man prüft, ob eine Liste in Java leer ist, indem man die Methode isEmpty() verwendet. Dies ist eine häufige Aufgabe in der Programmierung, und isEmpty() bietet eine klare und effiziente Möglichkeit, dies zu tun.

Zunächst erstellen wir eine neue Java-Datei namens ListCheck.java in Ihrem ~/project-Verzeichnis. Sie können dies tun, indem Sie mit der rechten Maustaste im Dateiexplorer links klicken und "Neue Datei" auswählen, und dann ListCheck.java eingeben.

Öffnen Sie nun ListCheck.java im Editor und fügen Sie folgenden Code hinzu:

import java.util.ArrayList;
import java.util.List;

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());
    }
}

Lassen Sie uns diesen Code analysieren:

• import java.util.ArrayList; und import java.util.List;: Diese Zeilen importieren die notwendigen Klassen, um mit Listen zu arbeiten.
• List<String> emptyList = new ArrayList<>();: Diese Zeile erstellt eine neue leere Liste, die String-Objekte enthalten kann.
• List<String> populatedList = new ArrayList<>();: Diese Zeile erstellt eine weitere neue Liste.
• populatedList.add("Apple"); und populatedList.add("Banana");: Diese Zeilen fügen Elemente zur populatedList hinzu.
• System.out.println("Is emptyList empty? " + emptyList.isEmpty());: Diese Zeile ruft die Methode isEmpty() auf emptyList auf. Die Methode isEmpty() gibt true zurück, wenn die Liste keine Elemente enthält, und false sonst. Das Ergebnis wird dann auf der Konsole ausgegeben.
• System.out.println("Is populatedList empty? " + populatedList.isEmpty());: Diese Zeile macht dasselbe für populatedList.

Speichern Sie die Datei ListCheck.java.

Öffnen Sie nun das Terminal unten im WebIDE und stellen Sie sicher, dass Sie sich im ~/project-Verzeichnis befinden. Sie können den Befehl cd ~/project verwenden, falls erforderlich.

Kompilieren Sie den Java-Code mit dem Befehl javac:

javac ListCheck.java

Wenn keine Fehler auftreten, wird eine ListCheck.class-Datei im ~/project-Verzeichnis erstellt.

Führen Sie schließlich das kompilierte Java-Programm mit dem Befehl java aus:

java ListCheck

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Is emptyList empty? true
Is populatedList empty? false

Diese Ausgabe bestätigt, dass isEmpty() die leere Liste und die Liste mit Elementen korrekt identifiziert hat. Die Verwendung von isEmpty() ist die bevorzugte Methode, um in Java auf eine leere Liste zu prüfen, da sie lesbarer und möglicherweise effizienter ist als die Prüfung der Größe.

Überprüfung der Listengröße mit size()

Im vorherigen Schritt haben wir gelernt, wie man prüft, ob eine Liste leer ist, indem man die Methode isEmpty() verwendet. Während isEmpty() hervorragend geeignet ist, um zu prüfen, ob eine Liste irgendeine Elemente enthält, müssen Sie manchmal genau wissen, wie viele Elemente sich in einer Liste befinden. Hierfür bietet Java die Methode size().

In diesem Schritt werden wir die Datei ListCheck.java ändern, um die Methode size() zu verwenden und zu verstehen, wie sie funktioniert.

Öffnen Sie die Datei ListCheck.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist. Sie sollte sich in Ihrem ~/project-Verzeichnis befinden.

Fügen wir nun einige Zeilen zur main-Methode hinzu, um die Größe unserer Listen auszugeben. Fügen Sie die folgenden Zeilen nach den Zeilen hinzu, in denen Sie isEmpty() verwendet haben:

import java.util.ArrayList;
import java.util.List;

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());

        // Get and print the size of the lists using size()
        System.out.println("Size of emptyList: " + emptyList.size());
        System.out.println("Size of populatedList: " + populatedList.size());
    }
}

Wir haben zwei neue Zeilen hinzugefügt:

• System.out.println("Size of emptyList: " + emptyList.size());: Diese Zeile ruft die Methode size() auf emptyList auf. Die Methode size() gibt die Anzahl der Elemente in der Liste als Ganzzahl zurück.
• System.out.println("Size of populatedList: " + populatedList.size());: Diese Zeile macht dasselbe für populatedList.

Speichern Sie die Datei ListCheck.java.

Gehen Sie nun zurück zum Terminal im ~/project-Verzeichnis. Wir müssen den geänderten Java-Code neu kompilieren:

javac ListCheck.java

Wenn die Kompilierung erfolgreich ist, führen Sie das Programm erneut aus:

java ListCheck

Sie sollten nun eine Ausgabe ähnlich der folgenden sehen:

Is emptyList empty? true
Is populatedList empty? false
Size of emptyList: 0
Size of populatedList: 2

Wie Sie sehen können, hat size() korrekt gemeldet, dass emptyList 0 Elemente und populatedList 2 Elemente hat.

Obwohl Sie theoretisch prüfen könnten, ob eine Liste leer ist, indem Sie überprüfen, ob ihre Größe 0 ist (list.size() == 0), wird die Verwendung von isEmpty() im Allgemeinen aus Gründen der Klarheit und Lesbarkeit bevorzugt. size() ist jedoch unerlässlich, wenn Sie die genaue Anzahl der Elemente in einer Liste wissen müssen, beispielsweise wenn Sie durch die Liste iterieren oder Berechnungen basierend auf der Anzahl der Elemente durchführen.

Umgang mit Null-Listen

In den vorherigen Schritten haben wir mit Listen gearbeitet, die entweder leer waren oder Elemente enthielten. In der realen Programmierung kann jedoch ein Listen-Variablenwert null sein. Ein null-Verweis bedeutet, dass die Variable auf kein Objekt im Speicher zeigt. Wenn Sie versuchen, eine Methode wie isEmpty() oder size() auf einer null-Liste aufzurufen, wird eine NullPointerException ausgelöst, was ein häufiger Fehler in Java ist.

In diesem Schritt lernen wir, wie man null-Listen sicher behandelt, bevor man prüft, ob sie leer sind oder ihre Größe ermittelt.

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

Fügen wir eine neue Listen-Variable hinzu und setzen sie auf null. Dann zeigen wir, was passiert, wenn Sie versuchen, Methoden auf ihr aufzurufen, ohne auf null zu prüfen. Ändern Sie Ihre main-Methode, um folgenden Code einzuschließen:

import java.util.ArrayList;
import java.util.List;

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Create a null list
        List<String> nullList = null;

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());

        // Get and print the size of the lists using size()
        System.out.println("Size of emptyList: " + emptyList.size());
        System.out.println("Size of populatedList: " + populatedList.size());

        // --- This part will cause an error if uncommented ---
        // System.out.println("Is nullList empty? " + nullList.isEmpty()); // This line will cause a NullPointerException
        // System.out.println("Size of nullList: " + nullList.size());   // This line will also cause a NullPointerException
        // ----------------------------------------------------

        // Safely check for null before calling methods
        System.out.println("\nSafely checking for null:");
        if (nullList == null) {
            System.out.println("nullList is null.");
        } else {
            System.out.println("Is nullList empty? " + nullList.isEmpty());
            System.out.println("Size of nullList: " + nullList.size());
        }

        if (emptyList == null) {
             System.out.println("emptyList is null.");
        } else {
             System.out.println("Is emptyList empty? " + emptyList.isEmpty());
             System.out.println("Size of emptyList: " + emptyList.size());
        }
    }
}

Wir haben hinzugefügt:

• List<String> nullList = null;: Dies deklariert eine Listen-Variable und setzt ihren Wert auf null.
• Auskommentierte Zeilen, die eine NullPointerException verursachen würden.
• Eine if-Anweisung: if (nullList == null). Dies ist der entscheidende Teil für die Behandlung von null. Wir prüfen, ob die nullList-Variable null ist, bevor wir versuchen, irgendeine Methode auf ihr aufzurufen. Wenn sie null ist, geben wir eine Nachricht aus. Wenn sie nicht null ist, können wir sicher isEmpty() und size() aufrufen.
• Wir haben auch eine ähnliche Prüfung für emptyList hinzugefügt, um zu zeigen, dass die if-Bedingung auch für nicht-null-Listen korrekt funktioniert.

Speichern Sie die Datei ListCheck.java.

Kompilieren Sie den geänderten Code im Terminal:

javac ListCheck.java

Führen Sie das Programm aus:

java ListCheck

Die Ausgabe sollte wie folgt aussehen:

Is emptyList empty? true
Is populatedList empty? false
Size of emptyList: 0
Size of populatedList: 2

Safely checking for null:
nullList is null.
Is emptyList empty? true
Size of emptyList: 0

Beachten Sie, dass wir erfolgreich geprüft haben, ob nullList null war und die NullPointerException vermieden haben. Wir haben auch bestätigt, dass die Prüfung für emptyList korrekt funktioniert.

Denken Sie immer daran, zu prüfen, ob eine Liste (oder irgendein Objektverweis) möglicherweise null ist, bevor Sie Methoden auf ihr aufrufen. Dies ist eine grundlegende Praxis in Java, um NullPointerException-Fehler zu vermeiden. Ein häufiges Muster ist if (myList != null && !myList.isEmpty()), um in einer einzigen Bedingung zu prüfen, ob eine Liste nicht null und nicht leer ist.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob eine Liste in Java leer ist. Wir haben zunächst die Methode isEmpty() untersucht, die eine einfache und effiziente Möglichkeit bietet, festzustellen, ob eine Liste Elemente enthält. Wir haben Beispiel-Listen erstellt, sowohl leere als auch mit Elementen gefüllte, und isEmpty() verwendet, um ihren Zustand zu überprüfen und die boolesche Ausgabe zu beobachten.

Wir haben auch untersucht, wie man die Methode size() verwendet, um zu prüfen, ob eine Liste leer ist, indem man ihre Größe mit Null vergleicht. Diese Methode gibt die Anzahl der Elemente in der Liste zurück, und eine Größe von 0 zeigt an, dass die Liste leer ist. Schließlich haben wir das entscheidende Thema des Umgangs mit Null-Listen behandelt, bevor man auf Leerheit prüft, und gezeigt, wie man NullPointerException vermeidet, indem man eine Null-Prüfung hinzufügt.