Java length of Array: So verwendest du Array.length!

Das Array ermöglicht es dir, mehrere Werte desselben Java Datentypen zu speichern. Ein Array besteht aus zwei Hauptkomponenten, nämlich der festgelegten Länge und der Anzahl der Elemente. Die Länge eines Java Arrays ist definiert als die Anzahl der in einem Array enthaltenen Elemente. Die Länge von Arrays ist zum Zeitpunkt der Initialisierung festgelegt und kann nicht geändert werden.

Dieser Artikel beleuchtet die Bedeutung von Array.length und vermittelt die folgenden Lernziele.

• Wie ermittelt man die Länge eines Java Arrays?

• Wie prüft man die Länge eines eindimensionalen Arrays?

• Wie prüft man die Länge eines mehrdimensionalen Arrays?

Wie ermittelt man die Länge eines Java arrays?

In Java ist die Länge des Arrays fest und kann nach der Initialisierung nicht mehr geändert werden. Die Längeneigenschaft kann auf die folgende Art und Weise abgefragt werden:

Syntax

meinArray.length;

In der obigen Syntax stellt meinArray die Array-Variable dar, während die length-Eigenschaft mit dem Punkt(.) Operator auf die meinArray-Variable angewendet wird. Der Rückgabewert der Methode ist dabei ein Integer! Achtung: Es handelt sich hierbei nicht um eine Java Methode, sondern um eine Eigenschaft /Attribut des Array-Objekts!

Schauen wir uns nun an wir wie die Länge von eindimensionalen (1-D), zweidimensionalen (2-D) und dreidimensionalen (3-D) Arrays ermitteln können.

Wie ermittelt man die Länge von eindimensionalen Arrays?

Arrays haben verschiedene Dimensionen, z. B. eine Dimension, zwei Dimensionen und drei Dimensionen. Dieses Beispiel bezieht sich auf die Bestimmung der Länge von eindimensionalen Arrays.

public class ArrayLength {
    public static void main(String[] args) {
        String[] str = {
            "Java",
            "JavaScript",
            "jQuery"
        };
        System.out.println("Die Länge des Arrays ist: " + str.length);
    }
}

Im obigen Code,

• wird ein String-Array initialisiert
• auf das Array welches die Strings enthält, wird die length Methode angewendet, um die Anzahl der darin enthaltenen Elemente zu ermitteln

Ausgabe auf der Konsole:

Da es drei Elemente in dem Array gab, ist das Ergebnis 3.

Wie ermittelt man die Länge von zweidimensionalen Arrays?

Der unten angegebene Code nimmt ein 2-D-Array und prüft die Länge des Arrays.

public class ArrayLength {
    public static void main(String[] args) {
        int[][] meineZahlen = {
            {
                4,
                5,
                8
            },
            {
                3,
                5
            },
            {
                7,
                3
            },
            {
                4
            },
            {
                10,
                19
            }
        };
        System.out.println("Die Array.length beträgt: " + meineZahlen.length);
    }
}

Im obigen Code,

• wird die Variable meineZahlen mit Integerwerten deklariert und initialisiert. Bei der Initialisierung verwenden wir jedoch auch weitere Arrays, sodass dieses Konstrukt als 2-D Array bezeichnet wird.
• mit Hilfe der length-Eigenschaft ermitteln wir nun erneut die Anzahl an Elementen

Ausgabe auf der Konsole:

Die Ausgabe zeigt, dass die Länge des Arrays meineZahlen 5 beträgt, was auch im Code zu erkennen ist. Das liegt daran, dass nun jedes Array innerhalb unseres meineZahlen-Arrays als Element gilt und nicht die Elemente innerhalb dieser einzelnen Array-Elemente.

Wie können wir Array.length bei dreidimensionalen Arrays verwenden?

Die 3-D-Arrays können auf die gleiche Weise initialisiert werden wie die 2-D-Arrays. In diesem Beispiel würden wir die Länge eines 3-D-Arrays in Java ermitteln.

public class ArrayLength {
    public static void main(String[] args) {
        int[][][] meineZahlen = {
            {
                {
                    4,
                    5,
                    6
                }, {
                    8,
                    10,
                    12
                }
            },
            {
                {
                    3,
                    6,
                    9
                },
                {
                    14,
                    18,
                    22
                },
                {-16,
                    -25 - 36
                }
            }
        };
        System.out.println("Die Array.length ergibt: " + meineZahlen.length);
    }
}

Der Code wird im Folgenden erklärt,

• der Integer-Array meineZahlen wird initialisiert
• die drei Klammern [][][] geben an, dass ein 3-dimensionales Array initialisiert wird
• Die Eigenschaft length wird für meineZahlen verwendet, um die Anzahl der darin enthaltenen Elemente zu ermitteln.

Hinweis: Denke daran, dass die in mehrdimensionalen Arrays enthaltenen Elemente im Grunde Arrays sind, die in ihnen gespeichert werden.

Ausgabe

Die Ausgabe ist 2, das heißt, dass die Anzahl der in meineZahlen enthaltenen Arrays 2 ist.

Wie können wir nun die Länge der darin enthaltenen Arrays ermitteln?

Die mehrdimensionalen Arrays enthalten Unterarrays, die auch als verschachtelte Arrays bezeichnet werden können. In den obigen Abschnitten hast du gelernt, die Länge des gesamten mehrdimensionalen Arrays zu bestimmen. Hier zeigen wir, wie man die Länge der in einem mehrdimensionalen Array gespeicherten Arrays ermitteln kann.

public class ArrayLength {
    public static void main(String[] args) {
        int[][] meinArray = {
            {
                7,
                5,
                8,
                6,
                14
            },
            {
                2,
                4,
                6,
                8
            },
            {
                11,
                13,
                17
            },
            {
                3,
                8
            }
        };
        // Länge des Arrays mit Array.length ermitteln
        System.out.println("Java length of Array / Länge des Arrays: " + meinArray.length);
        System.out.println("Nun zeigen wir die Länge der verschachtelten Arrays");

        // Die Länge der verschachtelten Arrays mit Hilfe von Array.length ermitteln
        for (int i = 0; i < meinArray.length; i++)
            System.out.println(meinArray[i].length);
    }
}

Im obigen Code,

• wird ein 2-D-Array meinArray initialisiert, welches wiederum vier Arrays enthält
• die Länge von meinArray wird mit Hilfe der Array.length Eigenschaft ermittelt
• die Java for-Schleife wird zur Iteration über die Elemente von meinArray verwendet
• Der Schleifenkörper enthält eine print-Anweisung, die die Anzahl der in jedem Unter-Array (verschachteltes Array) enthaltenen Elemente ausgibt.

Ausgabe auf der Konsole:

Zunächst wird die Länge des Arrays meinArray ausgedruckt, und anschließend können die Längen der verschachtelten Arrays abgelesen werden.

Zusammenfassung – Java length of Array – Array.length

Die Array-Länge ist definiert als die Anzahl der in einem Array enthaltenen Elemente/Arrays. Dieser Artikel konzentriert sich auf die Eigenschaft Array.length und zeigt, wie man die Länge von 1-D-, 2-D- und 3-D-Arrays ermitteln kann. Die in 1-D-Arrays enthaltenen Elemente sind einzelne Elemente eines bestimmten Datentyps. Die in 2-D- und 3-D-Arrays enthaltenen Elemente sind hingegen Arrays. Es gibt verschiedene Arten von Arrays, darunter 1-D-, 2-D-, 3-D- und verschachtelte Arrays, die mit Hilfe der Array.length Eigenschaft ermittelt werden können.