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

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob ein Array in Java leer ist. Wir werden die grundlegende Technik zur Überprüfung der Länge des Arrays behandeln und auch darauf eingehen, wie Sie Fälle behandeln können, in denen das Array selbst null sein könnte. Sie werden diese Konzepte mit verschiedenen Array-Typen üben, um Ihr Verständnis zu festigen.

Skills Graph

Überprüfen der Array-Länge auf Null

In diesem Schritt lernen wir, wie man prüft, ob ein Array in Java leer ist, indem man seine Länge überprüft. Dies ist eine grundlegende Operation beim Arbeiten mit Arrays, um Fehler zu vermeiden.

Zunächst erstellen wir eine neue Java-Datei namens ArrayLengthCheck.java in Ihrem ~/project-Verzeichnis. Sie können dies über den WebIDE-Dateiexplorer auf der linken Seite tun. Klicken Sie mit der rechten Maustaste in den ~/project-Bereich, wählen Sie "Neue Datei" und geben Sie ArrayLengthCheck.java ein.

Öffnen Sie nun die Datei ArrayLengthCheck.java im Editor und fügen Sie den folgenden Code hinzu:

public class ArrayLengthCheck {

    public static void main(String[] args) {
        // Declare and initialize an empty integer array
        int[] emptyArray = {};

        // Declare and initialize an integer array with elements
        int[] populatedArray = {1, 2, 3, 4, 5};

        // Check the length of the empty array
        if (emptyArray.length == 0) {
            System.out.println("emptyArray is empty.");
        } else {
            System.out.println("emptyArray is not empty. Length: " + emptyArray.length);
        }

        // Check the length of the populated array
        if (populatedArray.length == 0) {
            System.out.println("populatedArray is empty.");
        } else {
            System.out.println("populatedArray is not empty. Length: " + populatedArray.length);
        }
    }
}

Lassen Sie uns die neuen Konzepte hier verstehen:

• int[] emptyArray = {};: Dies deklariert ein ganzzahliges Array namens emptyArray und initialisiert es als leeres Array.
• int[] populatedArray = {1, 2, 3, 4, 5};: Dies deklariert ein ganzzahliges Array namens populatedArray und initialisiert es mit fünf ganzzahligen Elementen.
• array.length: Dies ist eine Eigenschaft eines Arrays in Java, die Ihnen die Anzahl der Elemente im Array angibt.
• if (condition) { ... } else { ... }: Dies ist eine if-else-Anweisung, eine grundlegende Kontrollflussstruktur in der Programmierung. Sie ermöglicht es Ihrem Programm, Entscheidungen zu treffen. Wenn die condition in den Klammern wahr ist, wird der Code im if-Block ausgeführt. Andernfalls wird der Code im else-Block ausgeführt.

In diesem Code verwenden wir die .length-Eigenschaft, um zu prüfen, ob die Länge jedes Arrays gleich 0 ist. Wenn dies der Fall ist, geben wir eine Nachricht aus, die angibt, dass das Array leer ist. Andernfalls geben wir eine Nachricht aus, die angibt, dass es nicht leer ist, und geben auch seine Länge aus.

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

Öffnen Sie nun das Terminal unten im WebIDE. Stellen Sie sicher, dass Sie sich im ~/project-Verzeichnis befinden. Wenn nicht, verwenden Sie den Befehl cd ~/project.

Kompilieren Sie das Java-Programm mit dem javac-Befehl:

javac ArrayLengthCheck.java

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

Führen Sie nun das kompilierte Programm mit dem java-Befehl aus:

java ArrayLengthCheck

Sie sollten die folgende Ausgabe sehen:

emptyArray is empty.
populatedArray is not empty. Length: 5

Diese Ausgabe bestätigt, dass unser Programm das leere Array und das befüllte Array korrekt anhand ihrer Längen identifiziert hat. Das Überprüfen der Länge eines Arrays, bevor Sie versuchen, auf seine Elemente zuzugreifen, ist ein entscheidender Schritt, um Fehler wie ArrayIndexOutOfBoundsException zu vermeiden, die auftreten, wenn Sie versuchen, auf ein Element an einem Index zuzugreifen, der im Array nicht existiert.

Umgang mit Null-Arrays

Im vorherigen Schritt haben wir gelernt, wie man prüft, ob ein Array leer ist, indem man seine Länge überprüft. Es gibt jedoch noch ein weiteres wichtiges Szenario, das zu berücksichtigen ist: Was passiert, wenn das Array selbst null ist?

In Java kann eine Variable eine Referenz auf ein Objekt enthalten oder den speziellen Wert null haben, was bedeutet, dass sie auf kein Objekt verweist. Wenn Sie versuchen, auf die .length-Eigenschaft einer Array-Variablen zuzugreifen, die null ist, stürzt Ihr Programm mit einer NullPointerException ab. Dies ist ein sehr häufiger Fehler in Java, daher ist es wichtig zu wissen, wie man ihn behandelt.

Lassen Sie uns unser vorheriges Programm ändern, um null-Arrays zu demonstrieren und zu behandeln.

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

Ersetzen Sie den vorhandenen Code durch den folgenden:

public class ArrayLengthCheck {

    public static void main(String[] args) {
        // Declare an integer array but do not initialize it (it will be null)
        int[] nullArray = null;

        // Declare and initialize an empty integer array
        int[] emptyArray = {};

        // Declare and initialize an integer array with elements
        int[] populatedArray = {1, 2, 3, 4, 5};

        // Function to check if an array is null or empty
        checkArrayStatus(nullArray, "nullArray");
        checkArrayStatus(emptyArray, "emptyArray");
        checkArrayStatus(populatedArray, "populatedArray");
    }

    // A helper method to check and print the status of an array
    public static void checkArrayStatus(int[] arr, String arrayName) {
        System.out.println("Checking " + arrayName + "...");
        if (arr == null) {
            System.out.println(arrayName + " is null.");
        } else if (arr.length == 0) {
            System.out.println(arrayName + " is empty.");
        } else {
            System.out.println(arrayName + " is not empty. Length: " + arr.length);
        }
        System.out.println(); // Print a blank line for better readability
    }
}

Schauen wir uns die Änderungen an:

• int[] nullArray = null;: Wir deklarieren eine Ganzzahl-Array-Variable nullArray und setzen ihren Wert explizit auf null.
• public static void checkArrayStatus(int[] arr, String arrayName): Wir haben eine neue Methode namens checkArrayStatus erstellt. Diese Methode nimmt ein Ganzzahl-Array (arr) und einen String (arrayName) als Eingabe. Dies hilft uns, die Logik zur Überprüfung des Array-Status wiederzuverwenden.
• if (arr == null): Dies ist der entscheidende Teil für die Behandlung von null-Arrays. Wir prüfen zunächst, ob die Array-Variable arr null ist, indem wir den Gleichheitsoperator == verwenden. Wenn sie null ist, geben wir eine Nachricht aus und überprüfen keine weiteren Bedingungen für dieses Array.
• else if (arr.length == 0): Diese Prüfung wird nur durchgeführt, wenn das Array nicht null ist. Wenn das Array nicht null ist, prüfen wir dann, ob seine Länge 0 ist, um zu sehen, ob es leer ist.
• Die main-Methode ruft jetzt checkArrayStatus für jedes unserer Arrays (nullArray, emptyArray und populatedArray) auf.

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

Öffnen Sie das Terminal im ~/project-Verzeichnis.

Kompilieren Sie das geänderte Java-Programm:

javac ArrayLengthCheck.java

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

java ArrayLengthCheck

Sie sollten die folgende Ausgabe sehen:

Checking nullArray...
nullArray is null.

Checking emptyArray...
emptyArray is empty.

Checking populatedArray...
populatedArray is not empty. Length: 5

Diese Ausgabe zeigt, dass unser Programm das null-Array, das leere Array und das befüllte Array korrekt identifiziert hat. Indem wir auf null prüfen, bevor wir die Länge prüfen, verhindern wir die NullPointerException, die auftreten würde, wenn wir versuchen würden, auf .length eines null-Arrays zuzugreifen. Dies ist eine grundlegende bewährte Methode in der Java-Programmierung.

Testen mit verschiedenen Array-Typen

In den vorherigen Schritten haben wir mit einem Array von Ganzzahlen (int[]) gearbeitet. Es ist wichtig zu verstehen, dass die Konzepte des Prüfens auf null und des Überprüfens der .length-Eigenschaft auf Arrays jedes Datentyps in Java zutreffen, sei es primitive Typen wie int, double oder boolean oder Objekttypen wie String oder benutzerdefinierte Klassen.

Lassen Sie uns unser Programm noch einmal ändern, um das Prüfen des Status von Arrays verschiedener Typen zu demonstrieren.

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

Ersetzen Sie den vorhandenen Code durch den folgenden:

public class ArrayLengthCheck {

    public static void main(String[] args) {
        // Declare a null String array
        String[] nullStringArray = null;

        // Declare an empty double array
        double[] emptyDoubleArray = {};

        // Declare a boolean array with elements
        boolean[] populatedBooleanArray = {true, false, true};

        // Declare a String array with elements
        String[] populatedStringArray = {"apple", "banana", "cherry"};

        // Use the helper method to check different array types
        checkArrayStatus(nullStringArray, "nullStringArray");
        checkArrayStatus(emptyDoubleArray, "emptyDoubleArray");
        checkArrayStatus(populatedBooleanArray, "populatedBooleanArray");
        checkArrayStatus(populatedStringArray, "populatedStringArray");
    }

    // A generic helper method to check and print the status of an array
    // We use Object[] because it can represent an array of any object type
    // For primitive types, the check still works on the array reference itself
    public static void checkArrayStatus(Object arr, String arrayName) {
        System.out.println("Checking " + arrayName + "...");
        if (arr == null) {
            System.out.println(arrayName + " is null.");
        } else if (arr instanceof Object[]) {
            // For object arrays, we can cast and check length
            Object[] objectArray = (Object[]) arr;
            if (objectArray.length == 0) {
                 System.out.println(arrayName + " is empty.");
            } else {
                 System.out.println(arrayName + " is not empty. Length: " + objectArray.length);
            }
        } else if (arr.getClass().isArray()) {
             // For primitive arrays, we can't cast to Object[], but can still check length
             // using reflection or simply rely on the null check and the fact that
             // primitive arrays also have a .length property accessible directly
             // (though accessing it here would require more complex reflection)
             // For simplicity in this example, we'll just indicate it's a non-null, non-empty primitive array
             // A more robust check would involve reflection or overloaded methods for each primitive type
             try {
                 int length = java.lang.reflect.Array.getLength(arr);
                 if (length == 0) {
                     System.out.println(arrayName + " is empty.");
                 } else {
                     System.out.println(arrayName + " is not empty. Length: " + length);
                 }
             } catch (IllegalArgumentException e) {
                  System.out.println("Could not determine length for " + arrayName);
             }

        } else {
             System.out.println(arrayName + " is not an array.");
        }
        System.out.println(); // Print a blank line for better readability
    }
}

Schauen wir uns die Änderungen an:

• Wir haben Arrays verschiedener Typen erstellt: String[], double[] und boolean[].
• Die Methode checkArrayStatus nimmt jetzt Object arr als Parameter. Dies ermöglicht es ihr, Arrays beliebigen Typs zu akzeptieren, da alle Arrays in Java Objekte sind.
• Innerhalb von checkArrayStatus prüfen wir zunächst, ob arr null ist.
• Wenn es nicht null ist, verwenden wir instanceof Object[], um zu prüfen, ob es sich um ein Array von Objekten handelt. Wenn ja, casten wir es zu Object[] und prüfen seine .length.
• Wir fügen auch eine Prüfung arr.getClass().isArray() hinzu, um zu sehen, ob das Objekt ein Array ist (dies gilt sowohl für Objekt- als auch für primitive Arrays).
• Bei primitiven Arrays ist es schwierig, direkt auf .length in dieser generischen Methode zuzugreifen, ohne Reflection zu verwenden. Der bereitgestellte Code verwendet java.lang.reflect.Array.getLength(arr) als allgemeinere Möglichkeit, die Länge eines beliebigen Array-Typs zu erhalten.

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

Öffnen Sie das Terminal im ~/project-Verzeichnis.

Kompilieren Sie das geänderte Java-Programm:

javac ArrayLengthCheck.java

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

java ArrayLengthCheck

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Checking nullStringArray...
nullStringArray is null.

Checking emptyDoubleArray...
emptyDoubleArray is empty.

Checking populatedBooleanArray...
populatedBooleanArray is not empty. Length: 3

Checking populatedStringArray...
populatedStringArray is not empty. Length: 4

Dies zeigt, dass die Prinzipien des Prüfens auf null und des Überprüfens der Länge konsistent für verschiedene Array-Typen in Java gelten. Obwohl die generische Methode checkArrayStatus mit Object und Reflection komplexer ist, bleibt die Kernidee, zunächst auf null und dann auf .length zu prüfen, für bestimmte Array-Typen (wie int[], String[] usw.) dieselbe.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob ein Array in Java leer ist, indem man seine length-Eigenschaft untersucht. Wir haben eine Java-Datei ArrayLengthCheck.java erstellt und Code geschrieben, um sowohl leere als auch befüllte Ganzzahl-Arrays zu deklarieren. Indem wir eine if-else-Anweisung verwendet und die Länge des Arrays mit Null verglichen haben, konnten wir erfolgreich feststellen, ob jedes Array leer war oder nicht, und die Ergebnisse auf der Konsole ausgeben. Diese grundlegende Technik ist entscheidend, um Fehler beim Arbeiten mit Arrays zu vermeiden.