7.1 Einfache Arrays, Teil 1

Einführendes Beispiel

Eine Java-Methode soll die kleinere von zwei int-Zahlen zurückliefern. Hier eine spontane Lösungsidee:

Programm 1

   public int mini(int a, int b) 
   {
      if (a < b)
         return a;
      else
         return b;
   }

Wenn der erste Parameter kleiner ist als der zweite, wird er als die "kleinste Zahl" interpretiert und zurückgeliefert. Ist der erste Parameter nicht kleiner als der zweite, wird der zweite Parameter als "kleinste Zahl" zurückgeliefert, selbst dann, wenn er genau so groß ist wie der erste Parameter.

Nun wollen wir die Methode so erweitern, dass das Minimum von drei Zahlen zurückgeliefert wird.

Programm 2

   public int mini(int a, int b, int c) 
   {
      if ((a < b) && (a < c))
         return a;
      else
         if (b < c)
            return b;
         else
            return c;
   }

Zunächst wird geschaut, ob a die kleinste der drei Zahlen ist. Wenn das nicht der Fall ist, muss b oder c die kleinste Zahl sein. Dazu wird einfach b mit c verglichen und je nach Ergebnis b oder c als Wert zurückgegeben.

    public int mini(int a, int b) 
    {
      if (a < b)
         return a;
      else
         return b;
    }
    
    public int mini(int a, int b, int c) 
    {
      if ((a < b) && (a < c))
         return a;
      else
         return mini(b,c);
    }

Zurück zum eigentlichen Thema. Wir sind immer noch bei der Einführung zum Thema "Arrays".

Wenn wir die Methode auf vier Parameter erweitern, wird der Quelltext noch länger und unübersichtlicher, über fünf oder sechs Parameter wollen wir gar nicht mehr nachdenken.

Was ist überhaupt ein Array?

Ein Array ist eine endliche Menge völlig gleichartiger Variablen. Unser Array aus dem obigen Programm besteht aus 100 int-Variablen. Genau so gut könnte man einen Array erzeugen, der aus 200 double-Variablen oder 2127 String-Variablen besteht.

Wie deklariert man einen Array?

Ein Array wird in einer Java-Klasse ähnlich wie ein normales Attribut deklariert. Vergleichen wir einmal die Deklaration einer einzelnen int-Variable und eines Arrays aus lauter int-Variablen:

int eineZahl;
int[] achtZahlen;

Der Array heißt zwar achtZahlen, die Arraygröße ist jedoch noch nicht festgelegt; das geschieht erst bei der Initialisierung des Arrays (s.u.). Auf die gleiche Weise könnte man auch einen Array aus double-Zahlen oder Strings deklarieren:

double[] zwanzigZahlen;
String[] textseite;

Was passiert bei der Deklaration?

Bei der Deklaration teilt man dem Rechner bzw. dem Java-System mit, dass man einen Array haben möchte, und wie der Array heißen soll. Nähere Angaben, vor allem wie viele Elemente der Array haben soll, hat man noch nicht gemacht.

Nach der Deklaration

int[] achtZahlen;

hat man zwar eine Variable erzeugt, die "achtZahlen" heißt, aber in der Variable steht noch nichts drin, sie ist leer.

Für Experten: Die Variable zeigt noch nicht auf einen konkreten Platz im Arbeitsspeicher.

Wie initialisiert man einen Array?

Bei der Initialisierung wird die Zahl der gewünschten Arrayelemente festgelegt.

achtZahlen = new int[8];

Offensichtlich will man hier acht int-Zahlen verwenden.

public class KleinerTest
{
    int[] achtZahlen;
    
    public KleinerTest()
    {
       achtZahlen = new int[8];
       System.out.println(achtZahlen);
    }
}

Wie weist man einem Arrayelement Werte zu?

Ein Beispiel

achtZahlen[0] = 1;
achtZahlen[1] = 4;
achtZahlen[2] = 9;

Zur Zuweisung eines Wertes an ein Arrayelement benötigt man die Adresse dieses Elementes. Dazu dient der Index. Auf jedes Arrayelement kann direkt mithilfe des Index zugegriffen werden. Das erste Arrayelement hat immer den Index 0.

Weitere Beispiele mit ausführlichen Erläuterungen

zahl[0] = 13;

"zahl" ist hier der Bezeichner, 0 der Index, und 13 der Wert.

temperatur[12] = 27.3;

Hier heißt der Bezeichner "temperatur", der Index ist 12, und der zugewiesene Wert ist 27.3.

inventar[2] = new Gegenstand("Hammer",0,45,2);

Der Bezeichner heißt hier "inventar", der Index ist 2, und der Wert ist nichts anderes als ein neues Objekt der Klasse Gegenstand. Dieses neue Objekt wird in dieser Programmzeile erst erzeugt, das sieht man ja an dem Wort "new" und dem Aufruf des Konstruktors der Klasse Gegenstand.

for (int k=0; k<max; k++) liste[k] = k*k+3*k-2;

Hier haben wir ein schönes Beispiel, wie man mit Hilfe von for-Schleifen (oder anderen Schleifen) den Umgang mit Arrays erleichtern kann. Weitere Informationen dazu finden Sie auf der Spezialseite "Arrays und for-Schleifen".

Wie greift man auf den Wert von Arrayelementen zu?

Hier ein paar Beispiele

System.out.println(zahl[3]);

Ein Arrayelement kann mit dem println()-Befehl ausgegeben werden.

int ergebnis = zahl[2];

Den Wert eines Arrayelements kann man einer anderen Variablen zuweisen.

int summe = zahl[0] + zahl[1] + zahl[2];

Man kann mehrere Arrayelemente gleichzeitig auswerten.

if (zahl[1] < 0) 
			zahl[1] = 0;

Man kann innerhalb von if-Abfragen, while-Schleifen etc. auf den Wert bestimmter Arrayelemente zugreifen.

inventar[4].ausgeben();

In einem Objekt-Array kann auf die einzelnen Objekte zugegriffen werden, man kann sogar Methoden dieser Objekte aufrufen und ausführen lassen. Hier wird die ausgeben-Methode des fünften Elementes des Arrays inventar aufgerufen. Das ist möglich, weil jedes Arrayelement ein eigenes Objekt mit Attributen und Methoden ist.

Weitere Beispiele mit ausführlichen Erläuterungen

int y = zahl[0];

Das erste Arrayelement wird ausgelesen, der ausgelesene Wert wird dann an die int-Variable y überwiesen. Also hat y hinterher den gleichen Wert wie das erste Arrayelement.

System.out.println(temperatur[12]);

Das 13. Arrayelement (Index 12) wird ausgelesen, der ausgelesene Wert wird dann an den System.out.println()-Befehl übergeben und in das Konsolenfenster ausgegeben.

if (zahlenliste[4] >= 20)
   bedingung = true;
else
   bedingung = false;

Das fünfte Arrayelement wird ausgelesen und mit der Zahl 20 verglichen. Wenn der Wert dieses Arrayelementes größer oder gleich 20 ist, so wird die Variable bedingung - offenbar eine boolean-Variable - auf den Wert true gesetzt. Ist dies nicht der Fall, erhält bedingung den Wert false.

bedingung = (zahlenliste[4] >= 20);

Diese Anweisung macht exakt das Gleiche wie die vier Zeilen des vorherigen Beispiels. Der Ausdruck zahlenliste[4] >= 20 ist eine logische Bedingung, also entweder true oder false. Egal, welchen Wert diese Bedingung hat, das Ergebnis wird dann an die Variable bedingung überwiesen.

inventar[3].beschaedigen(20);

Der Array inventar speichert Objekte der Klasse Gegenstand - was man hier nicht gleich sieht. Jedes Objekt hat nicht nur Attribute, sondern auch Methoden. Diese Anweisung greift auf die Methode beschaedigen() des vierten Objektes des Arrays inventar zurück und ruft diese Methode mit dem Parameter 20 auf. Das vierte Objekt soll also um den Wert 20 beschädigt werden.

Arrays als Parameter von Methoden

Man kann Arrays als Attribute von Klassen verwenden. In unserem einführenden Beispiel mit den 100 Zahlen haben wir das auch gemacht. Dieses Vorgehen hat den Vorteil, dass alle Methoden der Klasse schreibend und lesend auf die Elemente des Arrays zugreifen können.

Manchmal will man aber auch einfach eine unabhängige und universell einsetzbare Methode schreiben, die eine Operation auf einen beliebigen int- oder double-Array ausführt (oder auf Arrays mit anderen Elementtypen). Wenn eine solche Methode wirklich unabhängig von einer bestimmten Klasse sein soll, darf man innerhalb der Methode nicht auf einen Array mit einem konkreten Namen zugreifen. Die Methode weiß ja noch gar nicht, wie der Array heißt, den sie bearbeiten oder auswerten soll. Außerdem soll die Methode auf viele verschiedene Arrays mit unterschiedlichen Namen zugreifen können. Erst dann ist die Methode universell als Werkzeug einsetzbar. Betrachten wir einmal, wie eine solche universelle Methode aufgebaut sein könnte:.

   public int mini(int[] zahlen)
   {
      int mini = zahlen[0];

      for (int i=1; i < zahlen.length; i++)
         if (zahlen[i] < mini)
            mini = zahlen[i];

      return mini;
   }

Das ist fast der gleiche Quelltext wie in unserem Einführungsbeispiel mit den 100 Zahlen. Allerdings heißt der Parameter jetzt nicht mehr "hundertZahlen", sondern einfach nur "zahlen", weil ja eine beliebige Anzahl von Arrayelementen übergeben werden kann. Das hängt ja davon ab, welche andere Methode mini() aufruft.

Die Deklaration des Parameters beginnt genau so wie die Deklaration eines Array-Attributs, nämlich mit der Nennung des Datentyps (hier int) und einem Paar eckiger Klammern, gefolgt von einem lokalen Namen, in unserem Beispiel zahlen.

Innerhalb der Methode kann dann auf die einzelnen Elemente des übergebenen Arrays lesend und schreibend zugegriffen werden, wie bereits weiter oben erklärt.