Theorieteil zu Folge 7

Arrays

1. Allgemeines über Arrays

Einfache Datenstrukturen sind Ihnen bereits bekannt: Es gibt Variablen vom Typ int, die ganze Zahlen speichern können, Variablen vom Typ float oder double, die reelle Zahlen speichern, und Variablen vom Typ boolean, die Wahrheitswerte speichern können.

Ein Array kann mehr: Er kann 10, 20, 100, 1000 oder mehr Variablen speichern, die allerdings alle vom gleichen Datentyp sein müssen. Die Variablen werden dann als Array-Elemente bezeichnet. Im Gegensatz zu den einfachen Datenstrukturen bezeichnet man Arrays als zusammengesetzte Datenstrukturen.

Jedes dieser Array-Elemente kann einzeln angesprochen werden - wie eine richtige Variable. Dazu gibt man erst den Namen des Arrays und dann in eckigen Klammern den Index des Array-Elementes an. Angenommen, der Array von int-Zahlen heißt "zahl" und wir wollen testen, ob das Array-Element mit dem Index 1 den Wert 0 hat, so können wir schreiben:

if (zahl[1] == 0)...

Wenn wir dem Array-Element mit dem Index 7 einen bestimmten Wert zuweisen wollen, so schreiben wir

zahl[7] = 100;

Die folgende Zeichnung zeigt, wie ein Array im Arbeitsspeicher des Rechners verwaltet wird:

1 Der Array im Arbeitsspeicher des Rechners

Hier sieht man, dass die Elemente eines Arrays im Arbeitsspeicher hintereinander angeordnet sind. Das erste Array-Element hat den Index 0. Dies ist wichtig zu wissen; viele Programmieranfänger nehmen irrtümlich an, das erste Array-Element habe den Index 1. Man muss auch immer zwischen dem Wert eines Array-Elementes und dem Index des Array-Elementes unterscheiden. In dem Array in Abb. 1 hat z.B. das Array-Element mit dem Index 5 den Wert 12.

Nachdem wir uns jetzt etwas vordergründig mit Arrays beschäftigt haben, wollen wir das Ganze noch mal etwas intensiver besprechen.

Ein Array ist eine Liste von gleichen Variablen. Jede dieser Variablen kann über einen bestimmten Index direkt angesprochen werden. Das erste Arrayelement hat den Index 0. Mit Hilfe von for-Schleifen kann man alle Arrayelemente verändern oder auslesen.

Einfache Datenstrukturen sind int, float, double, boolean und andere.

Zusammengesetzte Datenstrukturen bestehen aus mehreren gleichen oder verschiedenen einfachen Datenstrukturen. Der Array ist eine solche zusammengesetzte Datenstruktur.

2. Arrays - eine intensivere Betrachtung

2.1 Deklaration eines Arrays

Wenn man eine einzelne int-Variable deklarieren will, so schreibt man:

int zahl;

Will man einen Array von int-Variablen deklarieren, so muss man dagegen folgendes schreiben:

int[ ] zahl;

Mit dieser Deklaration ist noch nicht festgelegt worden, wie groß der Array sein soll; wieviele Elemente der Array also enthalten soll. Das kommt jetzt, in der

2.2 Initialisierung eines Arrays

Die Festlegung der Array-Größe erfolgt in der Initialisierung des Arrays. Wir schreiben:

zahl = new int[100];

wenn der Array 100 Zahlen umfassen soll. Die folgende Zeile

zahl = new float[250];

erzeugt dagegen Speicherplatz, in dem 250 float-Variablen untergebracht werden können.

2.3 Arrays, die Objekte speichern

Auf die gleiche Weise wie primitive Datentypen kann man auch Objekte in einem Array speichern. Siehe hierzu die Vertiefung zum Theorieteil.

Diese Vertiefung enthält auch die beiden Übungen 7.2 (4 Punkte) und 7.3 (4 Punkte).

2.4 Zugriff auf einzelne Array-Elemente

Beispiele für lesende Zugriffe

y = zahl[5];

Eine einfache Zuweisung; das sechste Arrayelement (Index = 5) wird ausgelesen und in der Variablen y gespeichert.

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

Der Inhalt des vierten Arrayelements wird in der Konsole ausgegeben.

if (zahl[i] > 100) j = zahl[i+1];

Wenn der Wert des Arrayelementes mit dem Index i größer ist als 100, so wird der Variable j der Wert des nächsten Arrayelements zugewiesen.

if (zahl[j] > zahl[j+1]) swap();

Wenn ein Arrayelement größer ist als sein rechter Nachbar, so wird die Methode swap() aufgerufen.

berechneMittelwert(zahl[j+1],zahl[j+2]);

Array-Elemente können auch als Parameter für eingesetzt werden. Hier werden zwei benachbarte Array-Elemente an eine Methode berechneMittelwert() übergeben.

Beispiele für schreibenden Zugriff

zahl[6] = y;
zahl[8] = zahl[9];

Diese Beispiele sind nicht sehr kompliziert. In der ersten Zeile erhält das Array-Element Nummer 6 den Wert zugewiesen, der in der Variable y gespeichert ist. In der zweiten Zeile wird ein Wert von einem Array-Element auf ein anderes Array-Element übertragen.

2.5 Zugriff auf den gesamten Array

Will man auf alle Elemente eines Arrays zugreifen, so verwendet man dazu am besten eine for-Schleife.

Will man zum Beispiel alle Elemente eines Arrays aus 100 Zahlen ausgeben, so sieht dies so aus:

for (int i = 0; i < 100; i++) 
   System.out.println
      ("Zahl "+i+" = " + zahl[i]);

public boolean enthaelt13()
{
   for (int k = 0; i < 100; k++)
      if (zahl[k] == 13) return true;
   return false;
}

Der Array wird von vorn durchsucht. Wenn die Zahl 13 gefunden wurde, wird der return-Befehl mit dem Wert true ausgeführt; die for-Schleife wird abgebrochen und die Methode verlassen. Ist der Wert 13 nicht im Array enthalten, so wird die for-Schleife komplett durchlaufen, und danach wird der return-Befehl mit dem Wert false ausgeführt.

2.6 Übungen

public boolean enthaelt(int a, int b)

public int minimum()

Zurück zur Folge 7

Diese HTML-Seite wurde erstellt von Ulrich Helmich am 17. März 2005 mit Golive 6 und geringfügig überarbeitet am 3. Februar 2008.