Wie deklariert man ein Array?

Die Abbildung zeigt die schematische Darstellung eines Arrays, in dem 5 Elemente gespeichert werden können. Diese Länge eines Arrays ist immer konstant und kann nach der Deklaration nicht mehr verändert werden.
Die gespeicherten Werte selbst müssen immer vom selben Datentyp sein. Zulässig sind hierbei 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.

Soll das obige Array z.B. zur Speicherung von int-Werten dienen, so erfolgt dessen Deklaration auf die folgende Weise:

int[] arr = new int[5];

Sie beginnt links mit der Nennung des zu speichernden Datentyps, gefolgt von einer öffnenden und einer schließenden eckigen Klammer. Dies gemeinsam kennzeichnet den vorliegenden Array-Datentyp. Nach dem dann 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 hier jedoch die Länge des Arrays, also die Anzahl seiner Speicherplätze als positiver, ganzzahliger Wert notiert werden. Ein Semikolon schließt den Ausdruck ab.
Wie bereits oben angesprochen, ist die Größe eines Arrays grundsätzlich nicht veränderlich. Vergrößert sich zur Laufzeit eines Programms die zu speichernde Anzahl der Werte, so muss dies bei der Deklaration entweder berücksichtigt werden, indem ein ausreichend großes Array deklariert wird oder es muss von Anfang an ein anderer Datentyp zur Speicherung verwendet werden, etwa eine ArrayList.
Umgekehrt können Speicherplätze eines Arrays leer bleiben. Beim Zugriff wird dann, je nach gespeichertem Datentyp, entweder der Standardwert oder null verwendet.
Die Klammern können übrigens prinzipiell auch statt nach dem Typ-Bezeichner, nach dem Variablen-Bezeichner geschrieben werden.

int arr[] = new int[5]; // nicht empfehlenswert

Empfehlenswert ist diese Schreibweise jedoch nicht und man sollte die Notierung der Klammern hinter dem Datentyp-Bezeichner bevorzugen, da nur auf diese Weise eine eindeutige Datentypangabe vorliegt.

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

int[] zahl;

Die Initialisierung eines Arrays

Ein neu erzeugtes Array ist zuächst noch leer. Seine Speicherplätze müssen noch besetzt werden.
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 Indices bei 0 beginnt, sodass ein Array der Länge 5 die Indices von 0 - 4 besitzt.

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;

Wie oben bereits erwähnt kann eine Array-Position auch leer bleiben. Ist dies der Fall, so wird beim Zugriff auf die Speicherposition der Standardwert des jeweiligen Datentyps verwendet.

Soll ein neu gebildetes Array sofort bei der Deklaration mit Werten belegt werden, so kann ein Array auch gleichzeitig deklariert und initialisiert werden. Dies geschieht auf die folgende Weise:

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

Die zu speichernden Werte werden dabei nach dem Zuweisungsoperator in geschweiften Klammern durch Kommata getrennt notiert. Die Größe des Arrays wird hierbei durch die Anzahl der angegebenen Werte festgelegt. In obigem Fall wurde somit ein Array der Länge 5 mit den Indices 0 bis 4 gebildet.
Achtung! Eine Neubelegung eines bestehenden Array-Objektes ist auf diese Weise jedoch nicht möglich.

Zugriff auf die gespeicherten Werte eines Arrays

Auf die in einem Array abgelegten Werte kann über den Index zugegriffen werden. Unter Bezug auf obiges Beispiel erfolgt der Zugriff auf den an vierter Stelle (Index 3!) gespeicherten 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. Für die Abbruchbedingung wird auf die Länge des Arrays zugegriffen. Sie kann über dessen Eigenschaft length ermittelt werden. Der an der jeweiligen Position gespeicherte Wert wird anschließend 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. Ein Array der Länge 3 enthält hier 3 Arrays, von denen jedes die Länge 5 hat. Es kann auf die folgende Weise deklariert werden.

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 obigem Beispiel besitzen die gespeicherten Arrays die gleiche Größe. Mehrdimensionale Arrays können jedoch auch Arrays unterschiedlicher Größe speichern. Sie müssen dann allerdings auf andere Weise erzeugt werden. Hier ein Beispiel für eine kombinierte Deklaration und Initialisierung eines solchen Arrays:

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 groß ist 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. Man beachte, wie innerhalb der inneren Schleife mit Hilfe des Index auf die an der jeweiligen Position gespeicherten Arrays zugegriffen wird.

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();
        }
    }
}