Array-Länge in Java ermitteln

Ein Java-Array speichert seine Größe dauerhaft, und Sie lesen diese Größe über das length-Feld aus. Dies ist eine der häufigsten Operationen mit Arrays – um über sie zu iterieren, das letzte Element zu finden oder zu prüfen, ob sie überhaupt Daten enthalten. Dieses Kapitel zeigt, wie length funktioniert, wie es sich von String.length() unterscheidet und wie man mehrdimensionale Arrays vermisst.

Das `length`-Feld verwenden

Jedes Array in Java stellt ein public final int length-Feld bereit, das die Anzahl der Elemente enthält. Es wird ohne Klammern gelesen, weil es ein Feld und keine Methode ist.

int[] scores = {88, 92, 75, 60, 100};
int size = scores.length;          // 5
System.out.println(scores.length); // 5

Der Wert wird beim Erstellen des Arrays festgelegt und ändert sich nie – Arrays in Java wachsen oder schrumpfen nicht. Wenn Sie eine veränderliche Kollektion benötigen, verwenden Sie stattdessen ArrayList, die size() als Methode bereitstellt. Das length-Feld funktioniert auf die gleiche Weise für Arrays jeden Typs: String[], double[] oder sogar ein Array aus Objekten.

Feld vs. Methode: `length` vs. `length()`

Eine häufige Fehlerquelle ist die Verwechslung von Arrays und Strings. Ein Array verwendet das Feld length; ein String verwendet die Methode length(). Der falsche Aufruf lässt sich nicht kompilieren.

int[] numbers = {1, 2, 3};
String text = "hello";

System.out.println(numbers.length);   // field, no ()  -> 3
System.out.println(text.length());    // method, with () -> 5

Typ	Größe ermitteln	Klammern?
Array (`int[]`, `String[]`, ...)	`array.length`	Nein
`String`	`str.length()`	Ja
`ArrayList`, `HashMap`, ...	`collection.size()`	Ja

Eine einfache Faustregel: Arrays sind das Einzige der drei, das ein bloßes Feld verwendet. Alles andere verwendet einen Methodenaufruf.

Leere Arrays und letztes Element behandeln

Ein mit der Größe 0 erstelltes Array ist ein reales, nicht-null-Objekt, dessen length 0 ist. Das unterscheidet sich von einer null-Referenz, die überhaupt keine Länge hat – das Lesen von .length auf null wirft eine NullPointerException. Um die Größe sicher zu verwenden, iterieren Sie von 0 bis length - 1, da der letzte gültige Index immer um eins kleiner als die Länge ist.

int[] empty = new int[0];
System.out.println(empty.length);          // 0, not an error

int[] data = {10, 20, 30};
int last = data[data.length - 1];          // 30
for (int i = 0; i < data.length; i++) {
    System.out.println(data[i]);
}

Wenn ein Array null sein könnte, prüfen Sie das zuerst: if (data != null && data.length > 0).

Mehrdimensionale Arrays vermessen

Ein zweidimensionales Array in Java ist eigentlich ein Array von Arrays. Das äußere length gibt die Anzahl der Zeilen an, und jede Zeile hat ihr eigenes length für die Spaltenanzahl dieser Zeile. Zeilen können sogar unterschiedliche Längen haben (ein jagged Array), daher lesen Sie immer die Länge jeder Zeile einzeln, anstatt eine einheitliche Breite anzunehmen.

int[][] grid = {
    {1, 2, 3},
    {4, 5},
    {6, 7, 8, 9}
};
System.out.println(grid.length);     // 3 rows
System.out.println(grid[0].length);  // 3 columns in row 0
System.out.println(grid[2].length);  // 4 columns in row 2

Um alle Elemente zu zählen, addieren Sie die Länge jeder Zeile, anstatt Zeilen mit Spalten zu multiplizieren – das funktioniert nur bei perfekt rechteckigen Gittern.

Ausgearbeitetes Beispiel

Das folgende Programm fasst all diese Ideen zusammen: ein flaches Array, den Unterschied zwischen Feld und Methode, ein leeres Array, den Zugriff auf das letzte Element und ein jagged 2D-Array, dessen Gesamtgröße durch Summieren der Zeilenlängen berechnet wird.

java— editable, runs on the server

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // A one-dimensional array: length is a final field, not a method.
        int[] scores = {88, 92, 75, 60, 100};
        System.out.println("scores.length = " + scores.length);

// Strings use length() (a method); arrays use length (a field).
        String word = "hello";
        System.out.println("word.length() = " + word.length());

// An empty array has length 0; it is NOT null.
        int[] empty = new int[0];
        System.out.println("empty.length = " + empty.length);

// Iterating safely: the last valid index is length - 1.
        int last = scores[scores.length - 1];
        System.out.println("last element = " + last);

// A 2D array is an array of arrays: outer length vs. each row length.
        int[][] grid = {
            {1, 2, 3},
            {4, 5},
            {6, 7, 8, 9}
        };
        System.out.println("grid.length (rows) = " + grid.length);
        System.out.println("grid[2].length (cols in row 2) = " + grid[2].length);

// Total elements in a jagged 2D array: sum each row's length.
        int total = 0;
        for (int[] row : grid) {
            total += row.length;
        }
        System.out.println("total elements in grid = " + total);

System.out.println("grid contents = " + Arrays.deepToString(grid));
    }
}

Was der Programmaufruf zeigt:

scores.length = 5 bestätigt, dass length als bloßes Feld ohne Klammern gelesen wird und die Anzahl der Elemente zurückgibt.
word.length() = 5 zeigt, dass die String-Größe von der Methode length() stammt, einem anderen Mechanismus als das Array-Feld.
empty.length = 0 beweist, dass ein Array mit der Länge null ein gültiges Objekt ist, nicht null, und das Lesen seiner Länge sicher ist.
last element = 100 zeigt, dass der letzte Index length - 1 ist, da die Indizierung bei 0 beginnt.
grid.length (rows) = 3 während grid[2].length 4 ist, was zeigt, dass das äußere length die Zeilen zählt und jede Zeile ihre eigene Länge trägt – summiert zu total elements in grid = 9.

Übung

Wie erhält man in Java korrekt die Anzahl der Elemente in einem int-Array namens 'data'?

data.lengthdata.length()data.size()length(data)

Das length-Feld verwenden

Feld vs. Methode: length vs. length()