Arrays

Bisher haben wir immer mit Variablen gearbeitet, die einen einzelnen Wert speichern konnten. Wenn wir mehrere Werte speichern wollten, haben wir einfach mehrere Variablen deklariert:

int number1;
int number2;

Manchmal wollen wir in einem Programm aber viele Werte vom gleichen Typ speichern. Wenn wir zum Beispiel eine Anwendung die Telefonnummern verwalten soll, ist dieser Ansatz zu unflexibel. Wen wir tausend Telefonnummern speichern wollen, können wir nicht tausend Variablen String phonenumber1 bis Stringphonenumber100 speichern.

Die Lösung zu diesem Problem sind Arrays. Arrays erlauben uns, eine, möglicherweise erst zur Laufzeit des Programmes bekannte, fixe Anzahl von Variablen gleichen Typs zu deklarieren. Um 1000 Zahlen zu speichern würden wir folgendes schreiben

int[] number = new int[1000];

und um 1000 Telefonnummern (die jeweils als String repräsentiert werden) würden wir schreiben

String[] phoneNumber = new String[1000];

Dies definiert das Analog zu 1000 Variablen vom Typ int respektive String. Um Werte in die Variablen zu speichern, können wir einfach den Index, der Variablen wie folgt angeben:

phoneNumber[0] = "079 000 11 22";
phoneNumber[1] = "076 111 22 33";

und genau so können wir Werte lesen:

System.out.println(phoneNumber[0]);

Die Grundidee sollte einfach und verständlich sein und sie können dies einfach mal selbst ausprobieren. Natürlich müssen wir uns dann aber noch einige Details anschauen.

Deklaration und Erzeugen von Arrays​

Wenn wir uns die Deklaration eines Arrays anschauen, sehen wir ein Muster. Der Datentyp entspricht dem Datentyp der Elemente, gefolgt von den Klammern [], welche das Array repräsentieren. Hier drei Beispiele:

String[] stringArray;
int[] intArray; 
double[] d; 

Der Datentyp String[] entspricht einem String-Array, der Datentyp int[] einem int-Array und so weiter.

Um einen Wert vom Typ Array zu erzeugen, schreiben wir zuerst das Schlüsselwort new. Danach folgt der Datentyp der Elemente und [n]. Dabei ist n die Anzahl Elemente (die Grösse) des Arrays.

new String[10]; // erzeugt String Array der Grösse 10
new int[3];     // erzeugt int Array der Grösse 3
new double[7];  // erzeugt double Array der Grösse 7

Java erlaubt uns auch, die Array Werte direkt beim Erzeugen des Arrays anzugeben:

new String[]{"first", "second", "third"};
new int[]{1, 2,3};
new double[]{1.0, 2.0, 3.0};

Zugriff auf Elemente​

Auch um auf die einzelnen Arrayelemente zuzugreifen nutzen wir die eckigen Klammern. Darin geben wir den Index des Elemets an, auf das wir zugreifen wollen:

String s = new String[]{"first", "second", "third"};
s[0];   // Zugriff auf erstes Element (Wert "first")
s[1];   // Zugiff auf zweites Element (Wert "second")
s[2];   // Zugriff auf drittes Element (Wert "third")

Auffallend ist, dass das erste Element den Index 0 hat, und nicht wie man vielleicht erwarten würde den Index 1. Dies ist in fast allen Programmiersprachen so. Der Grund dafür ist historisch und ist für das Verständnis in modernen Programmiersprachen nicht hilfreich. Wichtig ist einfach, dass Sie sich das so merken.

Mit dem Zugriffsoperator [] können wir sowohl Elemente lesen als auch schreiben:

s[0] = "newFirst";          // Schreibt Wert "newFirst" in String Variable s[0]
System.out.println(s[0]);   // gibt "newFirst" aus

Im folgenden Code kombinieren wir alle Elemente. Wir deklarieren ein Array und initialisieren es direkt. Dann geben wir alle Werte aus, indem wir mit einer for-Schleife darüber iterieren.

String[] array = new String[]{"first", "second", "third"};
for (int i = 0; i < array.length; i = i + 1) { 
    System.out.println("Element " + i +" hat den Wert " +array[i]);
}

Beachten Sie, dass wir in der for-Schleife array.length schreiben, um die Grösse des Arrays zu erfragen.

Experimente​

Experimentieren Sie am besten selbst mit dem Code:

• Können Sie das letzte Element ausgeben?
• Überlegen Sie sich weitere Abänderungen und probieren Sie diese zu lösen.

Haben Sie Fragen oder Bemerkungen? Schreiben Sie diese doch ins Forum