Folgendes Problem:

Wir wollen 10 Preise einlesen und den niedrigsten markieren:

19.95
23.95
24.95
18.95 <- niedrigster Preis
29.95
19.95
20.00
22.99
24.95
19.95

Alle Daten müssen eingelesen werden, bevor wir ausgeben können, daher müssen wir sie zwischenspeichern. Dafür zehn Variablen zu verwenden wäre sehr unflexibel. Was nun?

Durch

double[] data = new double[10];

deklarieren wir ein Array von Double-Werten der Größe 10.

Genauer:

1. Ein Array ist ein Verweis auf eine Abfolge fester Länge von Variablen des gleichen Typs, genannt Fächer (engl. slots).
2. Der Typ typ[] ist der Typ der Arrays mit Einträgen vom Typ typ.
3. Der Ausdruck new typ[n] liefert ein frisches Array vom Typ typ der Länge n zurück. Hier ist n ein Ausdruck vom Typ int.

Im Beispiel ist also data eine Arrayvariable, die ein frisches Array vom Typ double der Länge 10 enthält.

Im Rechner ist der Arrayinhalt als Block aufeinanderfolgender Speicherzellen repräsentiert. Das Array selbst ist ein Objekt, bestehend aus der Länge und der Speicheradresse des Blocks.

1. Bitte in einem neuen Projekt eine Klasse Felder erstellen, welches das Array aus obigem Beispiel enthält. Anschließend mit dem Objekt-Inspektor inspizieren und obige Erklärung nachvollziehen…

Durch

data[4] = 29.95;

setzen wir das Fach mit der Nummer 4 auf den Wert 29.95. Mit

System.out.println("Der Preis ist EUR" + data[4]);

können wir diesen Wert ausgeben.

data[4] verhält sich ganz genauso wie eine "normale" Variable vom Typ double.

Ist a ein Array und i ein Ausdruck des Typs int, so bezeichnet a[i] das Fach mit Index i des Arrays a.

Achtung: Diese Indizes beginnen bei Null (wie bei den Strings auch!). Es muss also i echt kleiner (eins weniger) als die Länge von a sein.

Im Beispiel sind die Fächer also

data[0], data[1], data[2], data[3], ... , data[9]

Ist a ein Array, so ist

a.length

die Länge des Arrays als Integer. (Achtung: nicht a.length()!!!)

Das ist nützlich, wenn man die Länge später (durch Editieren und Neukompilieren) vergrößern muss. a.length stellt sich dann automatisch mit um. Ein "festverdrahteter" Wert wie 10 müsste auch explizit umgeändert werden.

Die Länge wird abgerufen wie eine als public deklarierte (Instanz)variable. Man kann sie aber im Programm nicht verändern, d.h.

a.length = 20;

ist nicht erlaubt.

1. Ein Array ist ein Verweis auf eine Folge von Variablen, der sogenannten Fächer.
2. Arraytypen werden durch Anfügen von eckigen Klammern gebildet.
   Ein Arraytyp ist weder Objekt- noch Grunddatentyp.
3. Frische Arrays werden mit new erzeugt; die Länge des Arrays wird in eckigen Klammern angegeben.
4. Die Fächer eines Arrays werden durch Anfügen des in eckige Klammern gesetzten Index bezeichnet.
5. Ein auf diese Weise bezeichnetes Fach ist eine Variable. Man kann ihren Wert verwenden und ihr mit = einen neuen Wert zuweisen.
6. Arrayindizes beginnen immer bei 0.
7. Die Länge eines Arrays erhält man mit .length

Merke: Das "Durcharbeiten" eines Arrays erfolgt meist so:

for(int i = 0; i < a.length; i++) {
    ...
    // Bearbeiten des Faches mit Index i
    ...
}

double[] data;
System.out.println(data[5]);

ist falsch. data[5] wurde ja nicht initialisiert.

double[] data;
data[5] = 7;
System.out.println(data[5]);

ist aber auch falsch!

Der Grund ist, dass die Variable data selber noch gar nicht initialisiert wurde.

Man muss so einer Variable erst ein Array (= Verweis auf Folge von Variablen) zuweisen. Normalerweise macht man das mit new:

double[] data;
data = new double[10];

Man kann aber auch direkt einen Arrayausdruck zuweisen, z.B.

double[] data = {0,1,2,3,4,5,6,7,8,9};

Eine Array kann als Parameter übergeben werden:

public double mittelwert(double[] zahlen) {
    if (zahlen.length == 0) {
        return 0.0;
    }
    double summe = 0;
    for(int i = 0; i < zahlen.length; i++) {
        summe = summe + zahlen[i];
    }
    return summe/zahlen.length;
}

Man kann nun etwa mittelwert(data) aufrufen. Wert ist der Mittelwert von data.