Arrays in Java einfach erklärt

Thema in Kurzform

• Arrays in Java sind Objekte und können mit dem new-Operator oder alternativ mit einer Initialisierungsliste erstellt werden.
• Arrays haben eine feste Größe, die nach der Erstellung nicht mehr geändert werden kann.
• Die einzelnen Array-Elemente werden über Index-Nummern ausgewählt. Das erste Element in einem Array hat den Index 0.

Inhaltsverzeichnis

1. Arrays erstellen
2. Arrays und Schleifen
3. Multidimensionale Arrays
4. Übungen

Array erstellen

Die Elemente eines Arrays sollten logisch zusammenpassen. So können wir die Lottozahlen oder Ihre Lieblingsfilme in entsprechenden Arrays sammeln. Damit das aber auch funktioniert, gibt es noch eine technische Bedingung:

• Die einzelnen Array Elemente eines Arrays müssen denselben (oder kompatiblen) Datentyp haben.

Um ein Array zu erstellen, benutzen wir folgende allgemeine Syntax:

typ[] arrayName = new typ[Gesamtgröße];

Wir müssen also bei der Deklaration des Arrays den Datentyp angeben (int, String etc.), gefolgt von eckigen Klammern und dem gewünschten Namen des Arrays. Die Initialisierung (also alles nach dem = Zeichen) beginnt mit dem Schlüsselwort new, gefolgt (nochmal) vom Datentyp.

In den eckigen Klammern auf der rechten Seite schreiben wir die Gesamtgröße des Arrays. Das führt uns zu einer weiteren wichtigen Regel im Umgang mit Arrays:

• Das Array hat eine feste Größe; die Anzahl der Elemente kann nach seiner Erzeugung nicht mehr verändert werden.

Wollen wir nun beispielsweise ein Array mit Lottozahlen erzeugen, sieht der konkrete Java-Code so aus:

int[] lottozahlen = new int[6];

Nice. Fehlen nur noch die einzelnen Array-Elemente.

Array mit Elementen füllen

Die Elemente eines Arrays sind numerisch sortiert. Diese Nummern nennen wir Index-Nummern. Die Index-Nummerierung erfolgt dabei immer aufsteigend und zwar beginnend bei dem Index 0. Somit hat das erste Element eines Arrays immer den Index 0 und das letzte den Index [Array-Größe n] MINUS 1. Der Index ist so etwas wie die eindeutige „Adresse“ eines Elements in seinem Array. Ein kleines Schaubild macht die Sache klar:

Wir können die einzelnen Index-Nummern in eckigen Klammern auswählen, um an die jeweilige Position im Array ein neues Element zu platzieren:

int[] lottozahlen = new int[6];

lottozahlen[0] = 2;
lottozahlen[1] = 7;
lottozahlen[2] = 11;
lottozahlen[3] = 30;
lottozahlen[4] = 41;
lottozahlen[5] = 42;

Array mit Initialisierungsliste erstellen

Wir können das Erstellen und "Befüllen" eines Arrays auch in einem Schritt erledigen.

Wir setzen hierfür eine Initialisierungsliste ein:

int[] lottozahlen = {2, 7, 11, 30, 41, 42};

In einem Schritt das Array zu erstellen und Elemente hinzufügen, ist praktisch und übersichtlich. Dieser Weg wird häufig angewandt, wenn die Elemente beim Erstellen bereits bekannt sind.

Auf Elemente zugreifen

Um einzelne Elemente eines Arrays auszulesen, schreiben wir den entsprechenden Index in eckigen Klammern hinter den Arraynamen. Die folgende Tabelle gibt uns eine Übersicht über die Index-Positionen und Elemente für das Array lottozahlen:

Im praktischen Code-Einsatz sieht das dann so aus:

System.out.println(lottozahlen[3]); // 30
System.out.println(lottozahlen[5]); // 42

System.out.println(lottozahlen[2-1]); // 7

int addition = lottozahlen[0] + lottozahlen[1]; // 9

ArrayIndexOutOfBoundsException

Ein Fehler, der sehr häufig gemacht wird, ist der Versuch, auf ein Array-Element außerhalb der gültigen Index-Grenzen zuzugreifen. Für unser Lottozahlen-Beispiel mit der Länge 6 liegen die gültigen Index-Werte zwischen 0 und 5.

Die Benutzung von Indizes außerhalb dieses Bereichs führt zu einem Laufzeitfehler, der dem Java-Programmierer als ArrayIndexOutOfBoundsException bekannt ist. Zum Beispiel:

lottozahlen[6] = 8; // ArrayIndexOutOfBoundsException

Arrays und Schleifen

Wo Arrays sind, sind Schleifen nicht weit. Hier der Grund, warum:

// String-Array erzeugen:
String[] filmklassiker = {"Terminator",
                          "Casablanca",
                          "2001: Odyssee im Weltraum",
                          "Der Pate",
                          "Inception",
                          "Pulp Fiction",
                          "Fight Club",
                          "Schindlers Liste"
                         };

Wenn wir nun jedes Element auf der Konsole printen wollen, könnten wir das ganz naiv wie folgt tun:

System.out.println(filmklassiker[0]);
System.out.println(filmklassiker[1]);
System.out.println(filmklassiker[2]);
System.out.println(filmklassiker[3]);
System.out.println(filmklassiker[4]);
System.out.println(filmklassiker[5]);
System.out.println(filmklassiker[6]);
System.out.println(filmklassiker[7]);

Hüten Sie sich aber davor, jemals solch einen Code abzugeben. Um einen guten Programmierstil einzuhalten, sollten wir stets auf doppelten Code verzichten (Don't repeat yourself!). Nicht nur, dass es unelegant ist. Solch ein Code ist außerdem unpraktisch, lästig zu pflegen und häufige Fehlerquelle. Das gilt bereits für ein Array mit einer handvoll Elementen. Stellen Sie sich einmal ein Array mit 100 Elementen vor. Man würde sich lächerlich machen.

Die Lösung lautet: Einsatz einer Schleife:

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

Kurz und knackig!

Den Schleifentyp, den wir hier einsetzen, nennt man for-Schleife. Eine for-Schleife wird mit einer Schleifenvariablen i gesteuert, Der Startwert der Schleifenvariablen i ist 0 und er wird nach jedem Schleifendurchlauf um +1 erhöht. Die Schleifenbedingung lautet i < filmklassiker.length, das heißt: Die Schleife wird solange wiederholt, wie i kleiner als die Größe des Arrays ist.

Auf diese Art nimmt bei jedem Schleifendurchlauf die Schleifenvariablen nacheinander einen der gültigen Index-Werte an. Somit können wir alle Elemente eines Arrays auswählen.

Multidimensionale Arrays

Bisher haben wir nur mit eindimensionalen Arrays gearbeitet. Für komplexere Datenstrukturen genügt das aber oftmals nicht. Wir werden es dann mit multidimensionalen Arrays zu tun bekommen.

• Ein multidimensionales Array ist ein Array, dessen Elemente wiederum Arrays sind.

Da vor allem zweidimensionale Arrays recht häufig vorkommen, schauen wir uns diese jetzt mal genauer an.

Stellen Sie sich ein zweidimensionales Array als eine Art Gitter mit Koordinaten vor.

Wie man sieht, besteht ein zweidimensionales Array aus einer Reihe von untergeordneten Einzelarrays ("Subarrays"). Diese wiederum halten jeweils einzelne Elemente.

Erstellen wir nun mit Java ein zweidimensionales Array für int-Werte:

int[][] array = new int[4][5];

Man benötigt nun zwei eckige Klammern. Beim Erstellen des Array-Objekts schreiben wir in die erste eckige Klammer die Länge des übergeordneten "Hauptarrays", d.h. wieviele Subarrays es im Array gibt (hier: 4).

In die zweite eckige Klammer wird die Länge der einzelnen "Subarrays" eingetragen, also wieviele Einzelelemente jedes dieser "Subarrays" enthalten soll (hier: 5).

Jetzt können wir den einzelnen Array-Positionen konkrete Elemente zuweisen:

array[0][1] = 100;
array[1][4] = 150;

Nicht vergessen: Die Zählung der Elemente in einem Array beginnt mit der Indexnummer 0. So hat das zweite Element des ersten Subarrays den Wert 100 (array[0][1]=100;) und das fünfte Element des zweiten Subarrays den Wert 150 zugewiesen bekommen (array[1][4]=150;).

Die restlichen Array-Positionen wurden von uns nicht explizit hinzugefügt und haben somit allesamt den Standardwert 0.

Subarrays mit unterschiedlichen Längen

Mit der oben beschriebenen Variante zweidimensionale Arrays zu erstellen, sind alle untergeordneten Arrays gleich lang. In unserem Beispiel oben haben alle die Länge 5).

Wenn wir für die einzelnen Subarrays aber jeweils unterschiedliche Längen benötigen, können wir mehrdimensionaler Arrays mittels Initialisierungsliste erstellen:

int[][] array2D = {{2,4,1,34}, {1}, {9,10,14}};

System.out.println(array2D[0].length); // 4
System.out.println(array2D[1].length); // 1
System.out.println(array2D[2].length); // 3

Innerhalb der äußeren geschweiften Klammern befinden sich wiederum drei innere Paare geschweifter Klammern, in die wir die einzelnen Elemente der (hier: 3) Subarrays schreiben. Mithilfe der Array-Eigenschaft length fragen wir anschließend testweise die Länge der drei unterschiedlich großen Subarrays ab und erhalten erwartungsgemäß unterschiedliche Werte.

Übungen

double[] array = new double[3];
array[0] = 2.2;
array[1] = 3.3;
array[2] = 4.4;

System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);

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

char[] a1 = {'A', 'B', 'C'};
String[] a2 = new String[];
[]int a3 = new int[3];
double[][] a4 = new double[4];
int[][] a5 = {{4,2},{7},{}};
String[] = new String[4];

String[] a2 = new String[];

[]int a3 = new int[3];

double[][] a4 = new double[4];

String[] = new String[4];

schwer

Welche der untenstehenden Codes erzeugt ein zweidimensionales Array, das folgender Matrix gleicht:

// CODE A
int[][] matrix = new int[5][4];
for(int i=1;i<=5; i++) matrix[i][1]  = 1;

// CODE B
int[][] matrix = new int[5][4];
for(int i=0;i<5; i++) matrix[i][1]  = 1;

// CODE C
int[][] matrix = new int[4][5];
for(int i=1;i<=5; i++) matrix[i][1]  = 1;

// CODE D
int[][] matrix = new int[5][4];
for(int i=1;i<=5; i++) matrix[i][2]  = 1;

Lösung ein-/ausblenden

Lösung: B