So prüfen Sie, ob ein Java-Array Null-Elemente enthält

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob ein Java-Array Null-Elemente enthält. Die Behandlung von Null-Werten ist eine grundlegende Fähigkeit in der Java-Programmierung, um häufige Fehler wie NullPointerException zu vermeiden. Wir werden drei verschiedene Methoden untersuchen, um dies zu erreichen: das Iterieren durch das Array mithilfe einer Schleife, die Nutzung der Stärken der Stream-API und das Zählen der Anzahl der Null-Elemente im Array. Am Ende dieses Labs verfügen Sie über praktische Techniken, um Null-Werte in Ihren Java-Arrays effektiv zu identifizieren und zu verwalten.

Durch das Array iterieren, um auf Null-Werte zu prüfen

In diesem Schritt lernen wir, wie man in einem Java-Array auf null-Werte prüft, indem man durch seine Elemente iteriert. Die Behandlung von null-Werten ist in Java von entscheidender Bedeutung, um NullPointerExceptions zu vermeiden, die häufige Fehler sind.

Ein null-Wert in Java bedeutet, dass eine Variable auf kein Objekt verweist. Wenn Sie versuchen, auf eine Methode oder ein Feld einer Variable zuzugreifen, die null ist, tritt eine NullPointerException auf, was dazu führt, dass Ihr Programm abstürzt.

Lassen Sie uns ein einfaches Java-Programm erstellen, um zu zeigen, wie man durch ein Array iteriert und auf null-Elemente prüft.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor. Wenn Sie sie nicht geöffnet haben, können Sie sie im Dateiexplorer links im project-Ordner finden.
Ersetzen Sie den vorhandenen Code in HelloJava.java durch folgenden Code:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = new String[5]; // Declare an array of Strings with size 5
        names[0] = "Alice";
        names[1] = "Bob";
        names[2] = null; // Assign a null value
        names[3] = "Charlie";
        names[4] = null; // Assign another null value

        System.out.println("Checking array for null values:");

        // Loop through the array
        for (int i = 0; i < names.length; i++) {
            // Check if the current element is null
            if (names[i] == null) {
                System.out.println("Element at index " + i + " is null.");
            } else {
                System.out.println("Element at index " + i + " is: " + names[i]);
            }
        }
    }
}
```
Schauen wir uns die neuen Teile dieses Codes an:
- String[] names = new String[5];: Diese Zeile deklariert ein Array namens names, das 5 String-Objekte aufnehmen kann. Wenn Sie ein solches Array von Objekten erstellen, werden die Elemente automatisch auf null initialisiert.
- names[2] = null; und names[4] = null;: Wir weisen explizit null den Elementen an den Indizes 2 und 4 zu.
- for (int i = 0; i < names.length; i++): Dies ist eine Standard-for-Schleife, die durch das Array vom ersten Element (Index 0) bis zum letzten Element (names.length - 1) iteriert.
- if (names[i] == null): Innerhalb der Schleife prüft diese if-Anweisung, ob das Element am aktuellen Index i gleich null ist.
- System.out.println("Element at index " + i + " is null.");: Wenn das Element null ist, wird diese Zeile ausgeführt.
- System.out.println("Element at index " + i + " is: " + names[i]);: Wenn das Element nicht null ist, wird diese Zeile ausgeführt und der Wert des Elements ausgegeben.
Speichern Sie die Datei HelloJava.java (Strg+S oder Cmd+S).
Jetzt kompilieren wir das geänderte Programm. Öffnen Sie das Terminal unten im WebIDE und führen Sie folgenden Befehl aus:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, war die Kompilierung erfolgreich.
Führen Sie schließlich das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Checking array for null values:
Element at index 0 is: Alice
Element at index 1 is: Bob
Element at index 2 is null.
Element at index 3 is: Charlie
Element at index 4 is null.
```
Diese Ausgabe zeigt, dass unser Programm die null-Elemente im Array erfolgreich identifiziert und gemeldet hat.

In diesem Schritt haben Sie gelernt, wie man manuell durch ein Java-Array iteriert und jedes Element mithilfe einer einfachen if-Bedingung auf einen null-Wert prüft. Dies ist eine grundlegende Technik zur Behandlung potenzieller NullPointerExceptions.

Verwenden Sie die Stream-API, um Null-Werte zu erkennen

Im vorherigen Schritt haben wir eine herkömmliche for-Schleife verwendet, um in einem Array auf null-Werte zu prüfen. Mit Java 8 wurde die Stream-API eingeführt, die eine funktionalere und oft kompaktere Möglichkeit bietet, Datenkollektionen, einschließlich Arrays, zu verarbeiten. In diesem Schritt lernen wir, wie man die Stream-API verwendet, um null-Elemente zu erkennen.

Die Stream-API ermöglicht es Ihnen, Operationen auf einer Sequenz von Elementen deklarativ auszuführen. Das bedeutet, dass Sie beschreiben, was Sie tun möchten, anstatt wie Sie es tun (wie bei einer for-Schleife).

Lassen Sie uns unser HelloJava.java-Programm ändern, um die Stream-API zu verwenden, um die null-Elemente zu finden und auszugeben.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ersetzen Sie den vorhandenen Code durch folgenden:
```
import java.util.Arrays; // Import the Arrays class
import java.util.Objects; // Import the Objects class

public class HelloJava {
    public static void main(String[] args) {
        String[] names = new String[5];
        names[0] = "Alice";
        names[1] = "Bob";
        names[2] = null;
        names[3] = "Charlie";
        names[4] = null;

        System.out.println("Checking array for null values using Stream API:");

        // Convert the array to a Stream
        Arrays.stream(names)
              // Filter for null elements
              .filter(Objects::isNull)
              // Print each null element (or a message indicating null)
              .forEach(name -> System.out.println("Found a null element."));
    }
}
```
Lassen Sie uns die neuen Teile analysieren:
- import java.util.Arrays;: Wir müssen die Arrays-Klasse importieren, um ihre stream()-Methode zu verwenden.
- import java.util.Objects;: Wir importieren die Objects-Klasse, um die isNull()-Methode zu verwenden, die eine bequeme Möglichkeit ist, zu prüfen, ob ein Objekt null ist.
- Arrays.stream(names): Diese Zeile wandelt unser names-Array in einen Stream von String-Objekten um.
- .filter(Objects::isNull): Dies ist eine Zwischenoperation. Sie filtert den Stream und behält nur die Elemente, für die die Bedingung Objects.isNull(element) wahr ist (d. h. die Elemente, die null sind). Objects::isNull ist eine Methodenreferenz, eine Abkürzung für einen Lambda-Ausdruck name -> Objects.isNull(name).
- .forEach(name -> System.out.println("Found a null element."));: Dies ist eine Endoperation. Sie führt für jedes verbleibende Element im Stream (die null-Elemente nach dem Filtern) eine Aktion aus. In diesem Fall wird für jedes gefundene null-Element "Found a null element." ausgegeben.
Speichern Sie die Datei HelloJava.java.
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Checking array for null values using Stream API:
Found a null element.
Found a null element.
```
Diese Ausgabe bestätigt, dass die Stream-API die beiden null-Elemente im Array erfolgreich erkannt hat. Die Verwendung von Streams kann Ihren Code für bestimmte Operationen wie Filtern und Verarbeiten von Kollektionen lesbarer und ausdrucksstärker machen.

Null-Elemente zählen

In den vorherigen Schritten haben wir gelernt, wie man null-Elemente in einem Array sowohl mit einer for-Schleife als auch mit der Stream-API identifiziert. Manchmal müssen Sie möglicherweise nicht nur die null-Elemente identifizieren, sondern auch genau wissen, wie viele null-Elemente in einem Array vorhanden sind. In diesem Schritt lernen wir, wie man die Anzahl der null-Elemente mit der Stream-API zählt.

Die Stream-API bietet eine bequeme Methode namens count(), die, wenn sie auf einen Stream angewendet wird, die Anzahl der Elemente in diesem Stream zurückgibt. Wir können dies mit der filter()-Operation kombinieren, die wir zuvor verwendet haben, um nur die null-Elemente zu zählen.

Lassen Sie uns unser HelloJava.java-Programm noch einmal ändern, um die null-Elemente zu zählen und die Gesamtanzahl auszugeben.

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

Ersetzen Sie den vorhandenen Code durch folgenden:

import java.util.Arrays;
import java.util.Objects;

public class HelloJava {
    public static void main(String[] args) {
        String[] names = new String[5];
        names[0] = "Alice";
        names[1] = "Bob";
        names[2] = null;
        names[3] = "Charlie";
        names[4] = null;

        System.out.println("Counting null values using Stream API:");

        // Convert the array to a Stream
        long nullCount = Arrays.stream(names)
                              // Filter for null elements
                              .filter(Objects::isNull)
                              // Count the remaining elements (which are null)
                              .count();

        System.out.println("Total number of null elements: " + nullCount);
    }
}

Hier ist, was neu ist:

long nullCount = ... .count();: Nachdem wir den Stream gefiltert haben, um nur null-Elemente zu enthalten, rufen wir die Endoperation count() auf. Diese Operation gibt die Anzahl der Elemente im gefilterten Stream als long-Wert zurück, den wir in der Variable nullCount speichern.
System.out.println("Total number of null elements: " + nullCount);: Diese Zeile gibt die endgültige Anzahl der null-Elemente aus.

Speichern Sie die Datei HelloJava.java.
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
Counting null values using Stream API:
Total number of null elements: 2
```
Diese Ausgabe zeigt, dass unser Programm die beiden null-Elemente im Array korrekt gezählt hat. Die gemeinsame Verwendung der filter()- und count()-Methoden der Stream-API ist eine effiziente und lesbare Möglichkeit, bestimmte Arten von Elementen in einer Sammlung, einschließlich null-Werten, zu zählen.

Sie haben nun drei verschiedene Methoden gelernt, um null-Werte in einem Java-Array zu behandeln: die Verwendung einer herkömmlichen for-Schleife, um jedes Element zu prüfen, die Verwendung der Stream-API, um null-Elemente zu filtern und zu identifizieren, und die Verwendung der Stream-API, um null-Elemente zu filtern und zu zählen. Diese Techniken sind grundlegend für das Schreiben von robustem Java-Code, der NullPointerExceptions vermeidet.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man auf Null-Elemente in einem Java-Array mit verschiedenen Ansätzen prüft. Wir begannen damit, eine herkömmliche Schleife zu implementieren, um durch das Array zu iterieren und jedes Element explizit mithilfe einer if-Bedingung auf einen Null-Wert zu prüfen. Diese Methode bietet eine klare und grundlegende Möglichkeit, Null-Werte zu identifizieren und ist nützlich, um das grundlegende Konzept der Null-Behandlung in Arrays zu verstehen.

Anschließend haben wir modernere und kompaktere Techniken zur Null-Erkennung untersucht. Das Lab zeigte, wie man die Java Stream-API nutzen kann, um effizient auf Null-Werte zu prüfen. Dieser Ansatz nutzt Stream-Operationen, um die Array-Elemente zu verarbeiten und das Vorhandensein von Null-Werten in einem funktionaleren Stil zu bestimmen. Schließlich haben wir gelernt, wie man die Anzahl der Null-Elemente in einem Array zählt, was eine Möglichkeit bietet, das Ausmaß der vorhandenen Null-Werte zu quantifizieren. Diese Methoden bieten unterschiedliche Grade an Ausdrucksstärke und Effizienz für die Behandlung von Null-Werten in Java-Arrays.