Java Arrays

Ein Array in Java ist ein Container mit fester Größe, der eine Folge von Werten desselben Typs enthält. Sobald es erstellt wurde, ändert sich seine Länge nie mehr, und jedes Element kann genau einen Wert speichern — ein int, einen String, eine Referenz auf ein beliebiges Objekt — alles, was dem deklarierten Typ entspricht.

Arrays bilden die Grundlage, auf der die übrigen Java-Collections (ArrayList, HashMap und Ähnliche) aufgebaut sind. Sie sind zwar nicht so komfortabel wie jene höherstufigen Klassen, aber schnell, vorhersehbar und allgegenwärtig — als Methodenargumente, Rückgabewerte und in performance-kritischem Code.

Ein Array deklarieren

Der Typ eines Arrays besteht aus dem Elementtyp gefolgt von []:

int[] scores;       // an array of ints
String[] names;     // an array of String references
double[] prices;    // an array of doubles

Die eckigen Klammern können auch hinter dem Variablennamen stehen — int scores[]; — aber die Form int[] scores ist bei weitem gebräuchlicher und sollte bevorzugt werden.

Eine Variable zu deklarieren erzeugt noch kein Array; es wird lediglich ein Slot angelegt, der eine Referenz auf ein Array aufnehmen kann. Dieser Slot hat anfangs den Wert null.

Ein Array mit new erstellen

Um das Array tatsächlich zuzuweisen, verwendet man new mit einer Längenangabe:

int[] scores = new int[5];

Damit wird Platz für 5 int-Werte reserviert. Java initialisiert jeden Slot mit dem Standardwert des jeweiligen Typs:

• numerische Typen → 0 (bzw. 0.0)
• boolean → false
• char → '�' (das Null-Zeichen, Code-Punkt 0 — kein Leerzeichen)
• Referenztypen → null

scores enthält somit sofort {0, 0, 0, 0, 0}. Es gibt keinen „nicht initialisierten" Zustand — sobald das Array erstellt wurde, hat jede Position einen definierten Wert.

Array-Literale

Wenn die Inhalte bereits bekannt sind, kann man ein Literal verwenden:

int[] scores = {90, 85, 73, 100, 62};
String[] colors = {"red", "green", "blue"};

Die Länge wird aus der Anzahl der Elemente abgeleitet. Diese Form ist nur in derselben Zeile wie die Deklaration zulässig — man kann nicht später scores = {90, 85}; schreiben. Dafür verwendet man die explizite Form:

scores = new int[]{90, 85, 73, 100, 62};

Auf Elemente zugreifen

Elemente werden über einen nullbasierten Index gelesen und geschrieben, mithilfe eckiger Klammern:

int[] scores = {90, 85, 73, 100, 62};
System.out.println(scores[0]);   // 90
System.out.println(scores[4]);   // 62
scores[2] = 80;                  // replace 73 with 80

Gültige Indizes reichen von 0 bis length - 1. Ein Index außerhalb dieses Bereichs löst zur Laufzeit eine ArrayIndexOutOfBoundsException aus — Java gibt keine Standardwerte zurück und macht keinen Wrap-around.

Die Eigenschaft length

Jedes Array besitzt ein öffentliches, schreibgeschütztes Feld length, das seine Größe angibt:

int[] scores = {90, 85, 73, 100, 62};
System.out.println(scores.length);   // 5

Es handelt sich um ein Feld, nicht um eine Methode — keine Klammern. Das ist eine kleine Java-Eigenheit: Strings verwenden .length(), Arrays verwenden .length. Beide unterscheiden sich auch von Collections (list.size()). Die Formen lassen sich leicht verwechseln; der Compiler wird es einem mitteilen.

length ist bei der Erstellung festgelegt. Um ein Array zu „vergrößern", muss ein neues erstellt und der Inhalt kopiert werden — siehe das Kapitel Arrays kopieren.

Arrays speichern Referenzen, keine Kopien

Wenn der Elementtyp ein Objekt ist, speichert das Array Referenzen, nicht die Objekte selbst:

String[] colors = {"red", "green", "blue"};
String first = colors[0];
// first and colors[0] both reference the same "red" string

Bei primitiven Typen spielt dieser Unterschied keine Rolle — int-Werte werden hineinkopiert und herausgelesen. Bei Objekten hingegen führt eine Mutation eines Elements von außen dazu, dass auch das Array den geänderten Wert sieht, da beide dieselbe Referenz teilen.

Standardwerte und null-Arrays

Eine deklarierte, aber nicht zugewiesene Array-Variable hat den Wert null. Das Lesen von .length oder eines beliebigen Index darauf wirft eine NullPointerException:

int[] data;            // not initialized
// System.out.println(data.length);  // would throw NullPointerException
data = new int[3];
System.out.println(data.length);     // 3

Ein leeres Array — mit der Länge null — ist ein vollständig gültiges Array und üblicherweise die bessere Wahl für einen „leeren" Rückgabewert statt null:

int[] none = new int[0];
System.out.println(none.length);     // 0

Ein vollständiges Beispiel

Ein Array ausgeben

Eine häufige Überraschung: Gibt man ein Array direkt an System.out.println weiter, werden nicht seine Inhalte angezeigt. Stattdessen wird der Typ und der Identitäts-Hash des Arrays ausgegeben:

int[] scores = {90, 85, 73};
System.out.println(scores);   // e.g. [I@39ed3c8d  — not the values!

[I bedeutet „Array von int", und der Hexadezimalteil ist ein Identitäts-Hash, keine Daten. Um die Elemente zu sehen, verwendet man Arrays.toString aus dem Paket java.util:

import java.util.Arrays;

int[] scores = {90, 85, 73};
System.out.println(Arrays.toString(scores));   // [90, 85, 73]

Für verschachtelte (mehrdimensionale) Arrays verwendet man stattdessen Arrays.deepToString.

Wie geht es weiter?

Sie können ein Array erstellen und per Index auf Elemente zugreifen. Der nächste Schritt ist die Iteration — das Durchlaufen jedes Elements mit Array-Schleifen, damit man nicht scores[0], scores[1], scores[2] einzeln ausschreiben muss.

Übungen