Wie man prüft, ob ein Array in Java eine bestimmte Länge hat

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob ein Array in Java eine bestimmte Länge hat. Wir beginnen damit, zu verstehen, wie man die Größe eines Arrays mithilfe der integrierten length-Eigenschaft bestimmt.

Danach lernen Sie, wie Sie die Länge des Arrays mit einem erwarteten Wert vergleichen, um zu überprüfen, ob es der gewünschten Größe entspricht. Abschließend werden wir untersuchen, wie man Null-Arrays behandelt, wenn man ihre Länge prüft, um potenzielle Fehler zu vermeiden.

Verwenden der length-Eigenschaft für die Arraysgröße

In diesem Schritt lernen wir, wie man die Größe eines Arrays in Java mithilfe der length-Eigenschaft bestimmt. Das Verständnis der Größe eines Arrays ist grundlegend, um durch seine Elemente zu iterieren oder Operationen auszuführen, die von der Anzahl der enthaltenen Elemente abhängen.

In Java haben Arrays eine integrierte Eigenschaft namens length, die die Anzahl der Elemente speichert, die das Array aufnehmen kann. Diese Eigenschaft ist eine finale Variable, was bedeutet, dass ihr Wert nach der Erstellung des Arrays nicht mehr geändert werden kann.

Lassen Sie uns ein einfaches Java-Programm erstellen, um zu demonstrieren, wie man die length-Eigenschaft verwendet.

Ö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) {
        // Declare and initialize an integer array
        int[] numbers = {10, 20, 30, 40, 50};

        // Get the length of the array using the length property
        int arraySize = numbers.length;

        // Print the size of the array
        System.out.println("The size of the array is: " + arraySize);
    }
}
```
Schauen wir uns die neuen Teile dieses Codes an:
- int[] numbers = {10, 20, 30, 40, 50};: Diese Zeile deklariert ein ganzzahliges Array namens numbers und initialisiert es mit fünf ganzzahligen Werten.
- int arraySize = numbers.length;: Hier verwenden wir die length-Eigenschaft. numbers.length greift auf die Größe des numbers-Arrays zu, und wir speichern diesen Wert in einer ganzzahligen Variablen namens arraySize.
- System.out.println("The size of the array is: " + arraySize);: Diese Zeile gibt den in der arraySize-Variablen gespeicherten Wert in der Konsole aus.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt lassen Sie uns unser modifiziertes Programm kompilieren. Stellen Sie im Terminal sicher, dass Sie sich im Verzeichnis ~/project befinden, indem Sie cd ~/project ausführen. Führen Sie dann aus:
```
javac HelloJava.java
```
Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe.
Abschließend lassen Sie uns unser Programm ausführen:
```
java HelloJava
```
Sie sollten folgende Ausgabe sehen:
```
The size of the array is: 5
```
Diese Ausgabe bestätigt, dass die length-Eigenschaft die Anzahl der Elemente in unserem numbers-Array korrekt zurückgegeben hat.

Das Verständnis, wie man die Größe eines Arrays erhält, ist für viele Programmieraufgaben von entscheidender Bedeutung, wie z. B. das Durchlaufen aller Elemente oder die Reservierung von Speicherplatz für neue Arrays.

Vergleich mit der erwarteten Länge

In diesem Schritt bauen wir auf unserem Verständnis der length-Eigenschaft auf, indem wir die tatsächliche Größe eines Arrays mit einer erwarteten Größe vergleichen. Dies ist eine häufige Aufgabe in der Programmierung, insbesondere beim Validieren von Eingaben oder beim Gewährleisten der Datenintegrität.

Wir können bedingte Anweisungen (wie if-Anweisungen) verwenden, um zu prüfen, ob die Länge des Arrays einem bestimmten Wert entspricht.

Lassen Sie uns unser HelloJava.java-Programm ändern, um die Länge des Arrays mit einem erwarteten Wert zu vergleichen.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ersetzen Sie den aktuellen Code durch folgenden:
```
public class HelloJava {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        int expectedSize = 5; // We expect the array to have 5 elements

        int arraySize = numbers.length;

        System.out.println("The size of the array is: " + arraySize);
        System.out.println("The expected size is: " + expectedSize);

        // Compare the actual size with the expected size
        if (arraySize == expectedSize) {
            System.out.println("The array size matches the expected size.");
        } else {
            System.out.println("The array size does NOT match the expected size.");
        }
    }
}
```
Hier ist, was neu ist:
- int expectedSize = 5;: Wir deklarieren eine Ganzzahlvariable expectedSize und setzen sie auf 5, was die Größe ist, die wir für unser numbers-Array erwarten.
- System.out.println("The expected size is: " + expectedSize);: Wir geben die erwartete Größe zur Verdeutlichung aus.
- if (arraySize == expectedSize): Dies ist eine if-Anweisung, die prüft, ob der Wert von arraySize gleich dem Wert von expectedSize ist. Der ==-Operator wird für den Vergleich verwendet.
- System.out.println("The array size matches the expected size.");: Diese Zeile wird ausgeführt, wenn die Bedingung in der if-Anweisung wahr ist (die Größen stimmen überein).
- else: Dieses Schlüsselwort leitet den Codeblock ein, der ausgeführt wird, wenn die Bedingung in der if-Anweisung falsch ist.
- System.out.println("The array size does NOT match the expected size.");: Diese Zeile wird ausgeführt, wenn die Bedingung in der if-Anweisung falsch ist (die Größen stimmen nicht überein).
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich dieser sehen:
```
The size of the array is: 5
The expected size is: 5
The array size matches the expected size.
```
Diese Ausgabe zeigt, dass unser Programm die tatsächliche Arraygröße (5) korrekt mit der erwarteten Größe (5) verglichen hat und die entsprechende Nachricht ausgegeben hat.

Sie können versuchen, den Wert von expectedSize zu ändern oder Elemente aus dem numbers-Array hinzuzufügen/zu entfernen, um zu sehen, wie sich die Ausgabe ändert. Diese Übung hilft Ihnen zu verstehen, wie bedingte Logik mit Array-Eigenschaften funktioniert.

Test mit Null-Arrays

In diesem letzten Schritt werden wir untersuchen, was passiert, wenn Sie versuchen, auf die length-Eigenschaft eines Arrays zuzugreifen, das nicht initialisiert wurde oder null ist. Das Verständnis, wie man null-Werte behandelt, ist entscheidend, um Fehler in Ihren Programmen zu vermeiden.

In Java hat eine Variable, die deklariert, aber kein Objektreferenz zugewiesen wurde, einen Standardwert von null. Wenn Sie versuchen, auf eine Eigenschaft oder Methode eines null-Objekts zuzugreifen, wirft Java eine NullPointerException. Dies ist ein häufiger Laufzeitfehler, den Sie in der Java-Programmierung begegnen werden.

Lassen Sie uns unser Programm ändern, um zu sehen, was passiert, wenn wir versuchen, die length eines null-Arrays zuzugreifen und wie wir dies elegant behandeln können.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ersetzen Sie den aktuellen Code durch folgenden:
```
public class HelloJava {
    public static void main(String[] args) {
        int[] numbers = null; // Declare an array but set it to null

        // Attempt to access the length property (this will cause an error)
        // int arraySize = numbers.length; // Commenting this out to prevent error

        // How to safely check for null before accessing length
        if (numbers != null) {
            int arraySize = numbers.length;
            System.out.println("The size of the array is: " + arraySize);
        } else {
            System.out.println("The array is null. Cannot get its length.");
        }
    }
}
```
Hier ist eine Zusammenfassung der Änderungen:
- int[] numbers = null;: Wir deklarieren das numbers-Array, aber setzen seinen Wert explizit auf null. Dies bedeutet, dass die Variable numbers derzeit nicht auf ein tatsächliches Array-Objekt im Speicher verweist.
- // int arraySize = numbers.length;: Wir haben die Zeile auskommentiert, die versucht, direkt auf numbers.length zuzugreifen. Wenn wir diesen Code ohne die if-Prüfung ausführen würden, würde dies zu einer NullPointerException führen.
- if (numbers != null): Dies ist der entscheidende Teil für die Behandlung von null. Wir verwenden eine if-Anweisung, um zu prüfen, ob die Variable numbers nicht null ist. Der !=-Operator bedeutet "ungleich".
- int arraySize = numbers.length; System.out.println("The size of the array is: " + arraySize);: Dieser Codeblock wird nur ausgeführt, wenn numbers nicht null ist. Innerhalb dieses Blocks ist es sicher, auf numbers.length zuzugreifen.
- else: Dieser Block wird ausgeführt, wenn die if-Bedingung falsch ist, d. h., numbers ist null.
- System.out.println("The array is null. Cannot get its length.");: Diese Nachricht wird ausgegeben, wenn das Array null ist und informiert den Benutzer, dass die Länge nicht ermittelt werden kann.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten folgende Ausgabe sehen:
```
The array is null. Cannot get its length.
```
Diese Ausgabe zeigt, dass unser Programm korrekt erkannt hat, dass das Array null war und die Situation behandelt hat, ohne eine NullPointerException zu werfen.

Das Behandeln von null-Werten ist eine sehr wichtige Fähigkeit in der Java-Programmierung. Prüfen Sie immer, ob eine Objektreferenz null ist, bevor Sie versuchen, auf ihre Eigenschaften oder Methoden zuzugreifen, um Laufzeitfehler zu vermeiden.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man die Größe eines Arrays in Java mithilfe der integrierten length-Eigenschaft bestimmt. Diese Eigenschaft bietet eine einfache Möglichkeit, auf die Anzahl der Elemente zuzugreifen, die ein Array aufnehmen kann. Wir haben dies demonstriert, indem wir ein Ganzzahl-Array erstellt, auf seine length zugegriffen und das Ergebnis ausgegeben haben.

In den folgenden Schritten wird wahrscheinlich auf dieses grundlegende Konzept aufgebaut, um die Größe des Arrays mit einer erwarteten Länge zu vergleichen und potenzielle Szenarien mit null-Arrays zu behandeln. Dies wird unser Verständnis der Array-Manipulation in Java weiter festigen.