Wie deklariert man ein Array?

Arrays sind Datentypen zur Speicherung mehrerer Werte eines einzigen Typs. Ein Array ist in Java ein Objekt und wird mit new erzeugt.

Die Abbildung zeigt das Schema eines Arrays der Länge 5, das somit also 5 Werte speichern kann. Alle gespeicherten Werte müssen immer vom selben Typ sein. Zulässig sind beliebige primitive Datentypen oder Objekte. Selbst andere Arrays können in einem Array gespeichert werden. Siehe hierzu auch den Abschnitt über mehrdimensionale Arrays weiter unten.

Die Deklaration des obigen Arrays erfolgt für ein Array mit int-Werten auf die folgende Weise:

int[] arr = new int[5];

Die Deklaration beginnt links mit der Nennung des zu speichernden Datentyps, gefolgt von einer öffnenden und einer schließenden eckigen Klammer. Dies zusammen kennzeichnet den Array-Datentyp. Nach dem folgenden Variablen-Bezeichner, der den gängigen Konventionen entsprechen muss und dem Zuweisungsoperator, ist zur Erzeugung des Array-Objektes das Schlüsselwort new zu notieren. Ihm folgt wiederum der Datentyp mit eckigen Klammern. In diesen muss die Länge des Arrays, also die Anzahl der Speicherplätze des Arrays, als positiver, ganzzahliger Wert notiert werden. Ein Semikolon schließt den Ausdruck ab.
Die Größe eines Arrays ist grundsäthlich nicht veränderlich.
Prinzipiell können die Klammern übrigens auch statt nach dem Typ-Bezeichner, nach dem Variablen-Bezeichner geschrieben werden. Empfehlenswert ist dies jedoch nicht und und man sollte die Notierung der Klammern hinter dem Datentyp-Bezeichner bevorzugen.

Die einzelnen Einträge eines Arrays sind der Reihe nach durchnummeriert. Man spricht vom Index der jeweiligen Position. Dem obigen Schema ist zu entnehmen, dass die Zählweise der Inices bei 0 beginnt, sodass ein Array der Länge 5 die Indices von 0 - 4 besitzt. Dies prädestiniert sie, um in Schleifen mit Hilfe einer Zählvariablen angesprochen zu werden.

Soll ein Array ohne Objektbildung nur deklariert werden, ist auch die folgende Schreibweise möglich:

int[] zahl;

Die Initialisierung eines Arrays

Die Initialisierung eines Arrays erfolgt durch Zuweisung des jeweiligen Wertes zur speziellen Array-Position, die über den Index aufgerufen wird.

int[] arr = new int[5];
arr[0] = 24;
arr[1] = -7;
arr[2] = 123456;
arr[3] = 25;
arr[4] = -64;

Eine Array-Position kann auch leer bleiben. Ist dies der Fall, so wird beim Zugriff auf die Speicherposition der Standardwert des jeweiligen Datentyps verwendet.

Ein Array kann auch gleichzeitig deklariert und initialisiert werden:

int[] arr = {24, -7, 123456, 25, -64};

Zugriff auf die gespeicherten Werte eines Arrays

Auf die in einem Array abgelegten Werte kann über den Index zugegriffen werden. Anknüpfend an obigem Beispiel erfolgt der Zugriff auf den an vierter Stelle (Index 3!) gespeicherter Wert durch den folgenden Ausdruck:

int i = arr[3];    // 25

Das folgende Beispiel fasst das bisher gesagte zusammen. Es wird ein Array der Länge 5 erzeugt und in einer Schleife an jeder Position mit dem Wert des Zählindex belegt. Auf die Länge eines Arrays kann über die Eigenschaft length zugegriffen werden. Anschließend wird der gespeicherte Wert auf der Konsole ausgegeben.

public class ArrayDeklarierenClass {  
    public static void main(String[] args){
        // Array der Laenge 5 deklarieren
        int[] zahl = new int[5];
        int i=0;
        while(i<zahl.length){
            zahl[i]=i;
            System.out.println(zahl[i]);
            i++;
        }
    }
}

Mehrdimensionale Arrays

Arrays können selber auch andere Arrays enthalten. Man spricht dann von mehrdimensionalen Arrays. Nebenstehend ist das Schema eines zweidimensionalen Arrays dargestellt, das 3 Arrays der Länge 5 enthält und auf folgende Weise deklariert wird.

int[][] zahl = new int[3][5];

Theoretisch ist eine beliebige Speichertiefe denkbar. Aber bereits dreidimensionale Arrays sind schon nicht häufig zu finden, da die Lesbarkeit mit zunehmender Speichertiefe rapide abnimmt.

In der obigen Zeile wird ein Array erzeugt, das 3 Arrays speichert, von denen jedes die Größe 5 hat. >Mehrdimensionale Arrays können sogar Arrays unterschiedlicher Größe speichern:

int[][] zahlen = {{1,2,3}, {1,2,3,4}, {1,2,3,4,5}};

Empfehlenswert ist so etwas jedoch nicht, da die Gefahr eines Zugriffs auf ungültige Indices besteht und in diesem Fall eine IndexOutOfBoundsException geworfen wird.

Wie bei eindimensionalen Arrays auch, erfolgt der Zugriff auf die Werte bei mehrdimensionalen Arrays auch über die Indices.
Im folgenden Beispiel wird das bislang Erwähnte noch einmal leicht variiert zusammengefasst.
Es wird ein zweidimensionale Array deklariert und mit drei String-Arrays initialisiert, die jeweils vier Adressdaten enthalten. Das Array an der dritten Position (Index 2) wird anschließend durch ein anderes ersetzt. In zwei geschachtelten Schleifen wird der gesamte Inhalt schließlich ausgelesen.

public class ZweidimensionalesArray {

    public static void main(String[] args) {
        String[][] personen = {
                { "Klaus", "Meyer", "Schlossallee. 4", "12345 Janzweitweg" },
                { "Franz", "Schmitz", "Elisenstr. 18", "98765 Posenuckel" },
                { "Heinz", "Kunz", "Badstr. 1", "34567 Hintertupfingen" }};
        String[] person = new String[4];
        person[0] = "Elli";
        person[1] = "Schulze";
        person[2] = "Parkstr. 14";
        person[3] = "09876 Imwald";
        personen[2] = person;

        for (int i = 0; i < personen.length; i++) {
            for (int j = 0; j < personen[i].length; j++) {
                System.out.println(personen[i][j]);
            }
            System.out.println();
        }
    }
}