Wie man prüft, ob ein Array in Java null ist

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob ein Array in Java null ist. Wir beginnen damit, zu verstehen, wie man prüft, ob die Array-Referenz selbst null ist, um NullPointerExceptions zu vermeiden.

Danach werden wir untersuchen, wie man Null-Prüfungen mit Längen-Prüfungen kombiniert, um Arrays robuster zu verarbeiten. Abschließend können Sie Ihr Verständnis testen, indem Sie mit einem initialisierten leeren Array arbeiten.

Prüfen, ob die Array-Referenz null ist

In diesem Schritt lernen wir, wie man prüft, ob eine Array-Referenz in Java null ist. Das Prüfen auf null ist eine grundlegende Praxis in der Java-Programmierung, um NullPointerExceptions zu vermeiden, die häufige Laufzeitfehler sind.

Eine NullPointerException tritt auf, wenn Sie versuchen, eine Variable zu verwenden, die auf nichts verweist (sie ist null), als ob es sich um ein Objekt handele. Stellen Sie sich vor, Sie versuchen, eine Kiste zu öffnen, die es nicht gibt – das ist ähnlich wie bei einer NullPointerException.

Lassen Sie uns ein einfaches Java-Programm erstellen, um zu zeigen, wie man auf eine null-Array-Referenz prüft.

Ö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:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = null; // Deklarieren einer Array-Referenz und Setzen auf null

        // Prüfen, ob die Array-Referenz null ist, bevor man sie verwendet
        if (names == null) {
            System.out.println("The 'names' array is null.");
        } else {
            System.out.println("The 'names' array is not null.");
        }
    }
}
```
Schauen wir uns die neuen Teile dieses Codes an:
- String[] names = null;: Diese Zeile deklariert eine Array-Variable namens names, die String-Objekte enthalten kann. Anschließend weisen wir ihr sofort den Wert null zu. Das bedeutet, dass die Variable names derzeit auf kein tatsächliches Array-Objekt im Speicher verweist.
- if (names == null): Dies ist eine if-Anweisung, die in der Programmierung zur Entscheidungsfindung verwendet wird. Sie prüft, ob die Bedingung in den Klammern (names == null) wahr ist. Der ==-Operator wird verwendet, um zu vergleichen, ob die Variable names gleich null ist.
- System.out.println("The 'names' array is null.");: Diese Zeile wird nur ausgeführt, wenn die Bedingung names == null wahr ist.
- System.out.println("The 'names' array is not null.");: Diese Zeile wird nur ausgeführt, wenn die Bedingung names == null falsch ist (das heißt, names ist nicht null).
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm. Führen Sie im Terminal folgenden Befehl aus:
```
javac HelloJava.java
```
Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe.
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten folgende Ausgabe sehen:
```
The 'names' array is null.
```
Diese Ausgabe bestätigt, dass unsere Prüfung die names-Array-Referenz korrekt als null identifiziert hat.

Das Verständnis, wie man auf null prüft, ist entscheidend für das Schreiben robuster Java-Codes. Im nächsten Schritt werden wir untersuchen, was passiert, wenn wir versuchen, die Länge eines null-Arrays zu ermitteln, und wie man Prüfungen kombinieren kann.

Kombinieren von Null- und Längenprüfungen

Im vorherigen Schritt haben wir gelernt, wie man prüft, ob eine Array-Referenz null ist. Jetzt wollen wir untersuchen, was passiert, wenn wir versuchen, die Länge eines null-Arrays zu ermitteln, und wie man die null-Prüfung mit einer Prüfung auf die Länge des Arrays kombinieren kann.

Wenn Sie versuchen, die .length-Eigenschaft einer null-Array-Referenz zuzugreifen, wird eine NullPointerException ausgelöst. Dies liegt daran, dass Sie versuchen, auf eine Eigenschaft von etwas zuzugreifen, das nicht existiert.

Lassen Sie uns unser Programm ändern, um dies zu demonstrieren, und dann eine kombinierte Prüfung hinzufügen.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ersetzen Sie den gesamten Inhalt der Datei durch folgenden Code:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = null; // Deklarieren einer Array-Referenz und Setzen auf null

        // Versuch, die Länge eines null-Arrays zuzugreifen (verursacht einen Fehler)
        // int length = names.length; // Das Entfernen der Kommentarzeichen dieser Zeile würde eine NullPointerException verursachen

        // Kombinierte Prüfung auf null und Länge
        if (names != null && names.length > 0) {
            System.out.println("The 'names' array is not null and has elements.");
        } else {
            System.out.println("The 'names' array is null or empty.");
        }
    }
}
```
Hier ist, was neu oder geändert ist:
- Wir haben String[] names = null; beibehalten, um mit einem null-Array zu beginnen.
- Die auskommentierte Zeile // int length = names.length; zeigt, was passieren würde, wenn wir direkt auf die Länge zugreifen würden. Wir haben sie auskommentiert, damit das Programm nicht sofort abstürzt.
- if (names != null && names.length > 0): Dies ist die kombinierte Prüfung.
  - names != null: Dieser Teil prüft, ob die names-Array-Referenz nicht null ist.
  - &&: Dies ist der logische UND-Operator. Beide Bedingungen auf beiden Seiten von && müssen wahr sein, damit die gesamte Bedingung wahr ist.
  - names.length > 0: Dieser Teil prüft, ob die Länge des names-Arrays größer als 0 ist. Diese Prüfung wird nur durchgeführt, wenn der erste Teil (names != null) wahr ist, dank der Kurzschlussauswertung des &&-Operators in Java. Dies verhindert die NullPointerException.
- Der else-Block gibt jetzt eine Nachricht aus, die darauf hinweist, dass das Array entweder null oder leer ist.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm:
```
javac HelloJava.java
```
Wiederum wird bei Erfolg keine Ausgabe angezeigt.
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten folgende Ausgabe sehen:
```
The 'names' array is null or empty.
```
Diese Ausgabe zeigt, dass unsere kombinierte Prüfung korrekt erkannt hat, dass das Array entweder null oder leer war. Da wir es auf null initialisiert haben, war der erste Teil der if-Bedingung (names != null) falsch, und der else-Block wurde ausgeführt.

Das Kombinieren von Prüfungen auf diese Weise ist eine Standardmethode, um Array-Referenzen in Java sicher zu verarbeiten und zu vermeiden, dass Sie NullPointerExceptions erhalten, wenn Sie Eigenschaften wie die Länge prüfen oder auf Elemente zugreifen.

Testen mit initialisiertem leeren Array

In den vorherigen Schritten haben wir gelernt, wie man auf null-Array-Referenzen prüft und diese Prüfung mit einer Längenprüfung kombiniert. Wir haben gesehen, dass unsere kombinierte Prüfung ein null-Array korrekt identifiziert hat.

Jetzt wollen wir unsere kombinierte Prüfung mit einem Array testen, das nicht null ist, aber leer ist (also eine Länge von 0 hat). Dies ist ein weiterer häufiger Fall, den Sie begegnen werden.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ändern Sie die Zeile, in der wir das names-Array deklarieren und initialisieren. Ändern Sie String[] names = null; in String[] names = new String[0];. Der Rest des Codes, einschließlich der if-Anweisung mit der kombinierten Prüfung, sollte gleich bleiben.

Der aktualisierte Code sollte wie folgt aussehen:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = new String[0]; // Deklarieren und Initialisieren eines leeren Arrays

        // Kombinierte Prüfung auf null und Länge
        if (names != null && names.length > 0) {
            System.out.println("The 'names' array is not null and has elements.");
        } else {
            System.out.println("The 'names' array is null or empty.");
        }
    }
}
```
Hier ist die Änderung:
- String[] names = new String[0];: Diese Zeile erstellt jetzt ein neues Array von String-Objekten mit einer Größe von 0. Die Variable names verweist jetzt auf ein tatsächliches Array-Objekt im Speicher, aber dieses Array enthält keine Elemente. Es ist nicht null.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm:
```
javac HelloJava.java
```
Wenn die Kompilierung erfolgreich ist, wird keine Ausgabe angezeigt.
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten folgende Ausgabe sehen:
```
The 'names' array is null or empty.
```
Diese Ausgabe ist die gleiche wie bei einem null-Array. Lassen Sie uns verstehen, warum. Unsere if-Bedingung lautet if (names != null && names.length > 0).
- names != null: Dieser Teil ist jetzt wahr, weil names auf ein leeres Array-Objekt verweist.
- names.length > 0: Dieser Teil prüft, ob die Länge des Arrays größer als 0 ist. Da das Array eine Länge von 0 hat, ist diese Bedingung falsch.
- Da der zweite Teil der &&-Bedingung falsch ist, ergibt die gesamte Bedingung (names != null && names.length > 0) false, und der else-Block wird ausgeführt.

Dies zeigt, dass unsere kombinierte Prüfung sowohl null-Arrays als auch leere Arrays korrekt identifiziert, was oft das gewünschte Verhalten ist, wenn Sie ein Array nur verarbeiten möchten, wenn es Elemente enthält.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob eine Array-Referenz in Java null ist, um NullPointerExceptions zu vermeiden. Wir haben begonnen, indem wir ein einfaches Programm erstellt haben, um das Prüfen einer null-Array-Referenz mit einer if-Anweisung und dem ==-Operator zu demonstrieren.

Anschließend haben wir untersucht, wie man die null-Prüfung mit einer Längenprüfung kombiniert, um Fälle zu behandeln, in denen das Array nicht null ist, aber möglicherweise leer ist. Schließlich haben wir unsere kombinierte Prüfung mit einem initialisierten leeren Array getestet, um den Unterschied zwischen einer null-Array-Referenz und einem leeren Array zu verstehen.