Wie man prüft, ob eine Liste in Java null-Elemente enthält

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob eine Java-List null-Elemente enthält. Wir werden verschiedene Methoden untersuchen, um dies zu erreichen, beginnend mit der einfachen contains()-Methode. Sie lernen, wie Sie contains(null) verwenden können, um schnell festzustellen, ob in einer Liste ein null-Wert vorhanden ist.

Nach der ersten Prüfung führt das Lab Sie durch das Iterieren über eine Liste, um jedes Element manuell auf null zu prüfen. Dieser Ansatz bietet mehr Kontrolle und ermöglicht es, Szenarien mit mehreren null-Elementen zu behandeln, was ebenfalls behandelt wird. Am Ende dieses Labs werden Sie ein solides Verständnis verschiedener Techniken zum Identifizieren von null-Werten in Java-Listen haben.

Verwenden Sie contains() für die Null-Prüfung

In diesem Schritt werden wir untersuchen, wie man mithilfe der contains()-Methode prüft, ob in einer Java-List null-Elemente vorhanden sind. Während contains() normalerweise verwendet wird, um nach bestimmten Elementen zu suchen, kann es auch verwendet werden, um festzustellen, ob eine List null enthält.

Zunächst erstellen wir eine neue Java-Datei. Klicken Sie im Dateiexplorer links mit der rechten Maustaste im Verzeichnis ~/project, wählen Sie "Neue Datei" und benennen Sie sie NullCheckList.java.

Öffnen Sie jetzt NullCheckList.java im Editor und fügen Sie den folgenden Code hinzu:

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

public class NullCheckList {

    public static void main(String[] args) {
        // Create a List and add some elements, including null
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add(null); // Adding a null element
        names.add("Bob");

        // Check if the list contains null using contains()
        boolean containsNull = names.contains(null);

        // Print the result
        System.out.println("Does the list contain null? " + containsNull);
    }
}

Lassen Sie uns die neuen Teile dieses Codes analysieren:

• import java.util.List; und import java.util.ArrayList;: Diese Zeilen importieren die notwendigen Klassen, um mit List und ArrayList zu arbeiten.
• List<String> names = new ArrayList<>();: Dies erstellt eine neue ArrayList, die String-Objekte aufnehmen kann. Wir deklarieren sie als List, da List ein Interface ist, das ArrayList implementiert.
• names.add(null);: Diese Zeile fügt explizit einen null-Wert unserer Liste hinzu.
• boolean containsNull = names.contains(null);: Dies ist der Kern dieses Schritts. Wir rufen die contains()-Methode auf der names-Liste auf und übergeben null als Argument. Die Methode gibt true zurück, wenn die Liste null enthält, andernfalls false. Das Ergebnis wird in einer booleschen Variablen containsNull gespeichert.
• System.out.println("Does the list contain null? " + containsNull);: Diese Zeile gibt das Ergebnis unserer Prüfung in der Konsole aus.

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

Jetzt kompilieren und führen wir das Programm aus. Öffnen Sie die Konsole unten im WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

Kompilieren Sie den Code mit javac:

javac NullCheckList.java

Wenn die Kompilierung erfolgreich ist (keine Ausgabe bedeutet Erfolg), führen Sie den kompilierten Code mit java aus:

java NullCheckList

Sie sollten die Ausgabe sehen, die angibt, ob die Liste null enthält.

Iterieren Sie durch die Liste zur Prüfung auf Nullwerte

Im vorherigen Schritt haben wir die contains()-Methode verwendet, um zu prüfen, ob eine Liste null enthält. Obwohl einfach, sagt uns diese Methode nur, ob null vorhanden ist, nicht wo es sich befindet oder wie oft es vorkommt. Ein üblicherer und flexiblerer Weg, null-Elemente in einer Liste zu behandeln, ist es, die Liste mithilfe einer Schleife zu durchlaufen und jedes Element einzeln zu prüfen.

In diesem Schritt werden wir unser NullCheckList.java-Programm ändern, um die Liste zu durchlaufen und die Position (Index) aller null-Elemente zu identifizieren.

Öffnen Sie die Datei NullCheckList.java im WebIDE-Editor. Ersetzen Sie die vorhandene main-Methode durch den folgenden Code:

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

public class NullCheckList {

    public static void main(String[] args) {
        // Create a List and add some elements, including null
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add(null); // Adding a null element
        names.add("Bob");
        names.add("Charlie");
        names.add(null); // Adding another null element

        System.out.println("Checking list for null elements:");

        // Loop through the list using a for loop
        for (int i = 0; i < names.size(); i++) {
            // Get the element at the current index
            String name = names.get(i);

            // Check if the element is null
            if (name == null) {
                System.out.println("Null found at index: " + i);
            }
        }
    }
}

Schauen wir uns die Änderungen an:

• Wir haben ein weiteres null-Element zur Liste hinzugefügt, um das Finden mehrerer null-Werte zu demonstrieren.
• for (int i = 0; i < names.size(); i++): Dies ist eine Standard-for-Schleife, die von Index 0 bis (aber nicht einschließlich) der Größe der names-Liste iteriert. Die Variable i repräsentiert den aktuellen Index.
• String name = names.get(i);: Innerhalb der Schleife ruft names.get(i) das Element am aktuellen Index i ab und speichert es in der Variable name.
• if (name == null): Dies ist die entscheidende Prüfung. Wir verwenden den Gleichheitsoperator ==, um die Variable name mit null zu vergleichen. Wenn sie gleich sind, bedeutet dies, dass das Element am aktuellen Index null ist.
• System.out.println("Null found at index: " + i);: Wenn ein null-Wert gefunden wird, gibt diese Zeile eine Nachricht aus, die den Index angibt, an dem es gefunden wurde.

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

Jetzt kompilieren und führen Sie das geänderte Programm aus der Konsole im Verzeichnis ~/project aus:

javac NullCheckList.java

java NullCheckList

Sie sollten eine Ausgabe sehen, die die Indizes angibt, an denen null-Elemente in der Liste gefunden wurden.

Checking list for null elements:
Null found at index: 1
Null found at index: 4

Dieser Ansatz gibt uns detailliertere Informationen über die null-Elemente in der Liste, was oft erforderlich ist, um sie in Ihrem Programm angemessen zu behandeln.

Mehrere Null-Elemente verarbeiten

Im vorherigen Schritt haben wir erfolgreich eine Liste durchlaufen und die Indizes der null-Elemente identifiziert. Jetzt erweitern wir dies und zeigen, wie Sie diese null-Elemente behandeln können. "Behandeln" kann je nach Logik Ihres Programms unterschiedliche Dinge bedeuten, wie z. B. das Überspringen des null-Elements, das Ersetzen durch einen Standardwert oder das Ausführen einer bestimmten Aktion.

In diesem Schritt werden wir unser NullCheckList.java-Programm erneut ändern. Diesmal werden wir die Liste durchlaufen und für nicht-null-Elemente im Vergleich zu null-Elementen eine andere Nachricht ausgeben.

Öffnen Sie die Datei NullCheckList.java im WebIDE-Editor. Ersetzen Sie die vorhandene main-Methode durch den folgenden Code:

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

public class NullCheckList {

    public static void main(String[] args) {
        // Create a List and add some elements, including null
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add(null); // Adding a null element
        names.add("Bob");
        names.add("Charlie");
        names.add(null); // Adding another null element
        names.add("David");

        System.out.println("Processing list elements:");

        // Loop through the list using a for-each loop
        for (String name : names) {
            // Check if the element is null
            if (name == null) {
                System.out.println("Found a null element, skipping.");
            } else {
                // If the element is not null, process it
                System.out.println("Processing name: " + name);
            }
        }
    }
}

Schauen wir uns die Änderungen in dieser Version an:

• Wir haben ein weiteres nicht-null-Element ("David") zur Liste hinzugefügt.
• for (String name : names): Dies ist eine erweiterte for-Schleife (auch als for-each-Schleife bekannt). Sie ist eine bequeme Möglichkeit, über die Elemente einer Sammlung zu iterieren, ohne einen Index zu verwenden. In jeder Iteration wird die Variable name das aktuelle Element aus der names-Liste enthalten.
• if (name == null): Wir verwenden immer noch den ==-Operator, um zu prüfen, ob das aktuelle Element (name) null ist.
• System.out.println("Found a null element, skipping.");: Wenn das Element null ist, geben wir eine Nachricht aus, die angibt, dass wir es überspringen. In einer echten Anwendung könnten Sie hier eine andere Aktion ausführen, wie z. B. das Protokollieren des Null-Werts oder das Zuweisen eines Standardwerts.
• else { System.out.println("Processing name: " + name); }: Wenn das Element nicht null ist, gelangen wir in den else-Block und geben eine Nachricht aus, die angibt, dass wir den nicht-null-Namen verarbeiten.

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

Jetzt kompilieren und führen Sie das geänderte Programm aus der Konsole im Verzeichnis ~/project aus:

javac NullCheckList.java

java NullCheckList

Sie sollten eine Ausgabe sehen, die die nicht-null-Namen verarbeitet und anzeigt, wenn ein null-Element gefunden wird.

Processing list elements:
Processing name: Alice
Found a null element, skipping.
Processing name: Bob
Processing name: Charlie
Found a null element, skipping.
Processing name: David

Dieses Beispiel zeigt eine grundlegende Möglichkeit, null-Elemente während der Iteration zu behandeln. Je nach Ihren spezifischen Anforderungen können Sie null durch einen Standardstring ersetzen, die null-Elemente aus der Liste entfernen oder andere Operationen ausführen. Der Schlüssel besteht darin, auf null zu prüfen, bevor Sie versuchen, das Element zu verwenden, da das Aufrufen von Methoden auf einem null-Objekt zu einer NullPointerException führt.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob eine Java-List null-Elemente enthält. Wir haben die Verwendung der contains()-Methode mit null als Argument untersucht, die eine einfache Möglichkeit bietet, die Anwesenheit eines einzelnen null-Elements festzustellen.

Wir haben eine Beispiel-ArrayList erstellt, sowohl gültige Elemente als auch einen null-Wert hinzugefügt und dann names.contains(null) verwendet, um die Prüfung durchzuführen. Das Ergebnis wurde auf der Konsole ausgegeben, was die Effektivität dieser Methode für eine grundlegende Null-Prüfung innerhalb einer Liste zeigt.