Arrays

Ein Array ist eine Zusammenfassung von Daten desselben Typs unter einem gemeinsamen Namen (Variable). Häufig verwendet man Arrays, um zusammengehörige Daten gemeinsam abzuspeichern, beispielsweise Messreihen einer Wetterstation oder Teilnehmer an einer Lehrveranstaltung.

Da alle Datensätze des Arrays unter demselben Namen ansprechbar sind, ist es notwendig, eine Möglichkeit zum Zugriff auf einzelne Werte zu schaffen. Dies geschieht durch eine Nummerierung. Die Werte sind im Array nummeriert gespeichert. Die Nummer, unter der ein Wert angesprochen (gelesen oder geschrieben) werden kann, nennt man Index.

Achtung

Die Zählung der Werte in einem Array beginnt mit der Zahl 0. Der erste Wert hat also den Index 0 und der letzte Wert den Index n - 1, wenn n die Anzahl der Werte ist.

Einführendes Beispiel

Temperaturmesswerte einer Wetterstation:

Uhrzeit	00:00	04:00	08:00	12:00	16:00	20:00
Temperatur	17.3	16.5	17.2	26.0	33.7	29.6

Zugehöriges Array:

Index	Wert
0	17.3
1	16.5
2	17.2
3	26.0
4	33.7
5	29.6

In Java:

// Arrays werden durch [] hinter dem Typ der Werte gekennzeichnet
double[] temperatur = {17.3, 16.5, 17.2, 26.0, 33.7, 29.6};

// Der Zugriff auf einen Wert erfolgt mit [] unter Angabe des Index
double mittagshitze = temperatur[3];

// mittagshitze enthält jetzt den Wert 26.0

Deklaration und Definition

Arrays werden durch eckige Klammern hinter dem Datentyp gekennzeichnet. Damit wird festgelegt, welcher Typ im Array gespeichert werden kann. Alle Elemente des Arrays müssen denselben Typ haben.

Allgemeine Form

datentyp[] name = new datentyp[Länge];

Arrays können auf verschiedene Arten deklariert und definiert werden:

// Array der Länge 5 mit Ganzzahlen
// Deklaration und Initialisierung getrennt
int[] zahlen;
zahlen = new int[5];

// Array der Länge 5 mit booleschen Werten
// Deklaration mit direkter Initialisierung
boolean[] bits = new boolean[5];

// Array der Länge 5 mit Zeichen
// Deklaration mit direkter und expliziter Initialisierung
// Diese Art der Initialisierung darf nur zusammen mit der
// Deklaration erfolgen, später nicht mehr.
char[] buchstaben = {'a', 'w', 'd', 's', 'q'};

Repräsentation im Speicher

Der Speicher der Java Virtual Machine ist sequenziell organisiert. Das bedeutet, dass die Speicherzellen, bei Null beginnend, aufsteigend nummeriert sind. Die Größe einer Speicherzelle entspricht dabei der Breite des Datenbusses, das sind aktuell üblicherweise 32 oder 64 bit.

Arrays sind sogenannte Referenztypen: Das Array belegt einen Speicherbereich einer festgelegten Größe (in oben gezeigten Beispiel mit den Temperaturmesswerten sechs Zellen der Größe double). Die Variable, unter der das Array angesprochen werden kann enthält die Nummer (auch Adresse genannt) der Speicherzelle 0 des Speicherbereiches des Arrays. Man sagt: Die Variable referenziert den Speicher des Arrays.

Beispiel mit Temperaturmesswerten:

Codebeispiel	Darstellung des Speichers
double[] temperatur = {17.3, 16.5, 17.2, 26.0, 33.7, 29.6}; double mittagshitze = temperatur[3]; // der Variablen temp 2 wird der Inhalt von temperatur, // die Adresse 42 zugeiwesen. Es werden keine Daten kopiert. double[] temp = temperatur; // temp und temperatur verweisen jetzt auf denselben Speicherbereich // Der Zugriff erfolgt also in denselben Speicherbereich double morgenfrische = temp[1];	Achtung! Die Speicheradressen sind willkürlich gewählt. Es gibt keinen besonderen Zusammenhang zwischen dem Quellcode und den Adressen. Variable oder Array-Index Speicheradresse Speicherinhalt ... 0 42 17.3 1 43 16.5 2 44 17.2 3 45 26.0 4 46 33.7 5 47 29.6 ... temperatur 77 42 (Verweis auf die Arraydaten) mittagshitze 78 26.0 ... temp 93 42 (Verweis auf die Arraydaten) morgenfrische 94 16.5 ...

Grundlegende Operationen auf / mit Arrays

Arraylänge bestimmen

double[] a= new double[23];
int laenge = a.length;

Array-Durchlauf

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

oder

for (int e : a) {
  System.out.println(e);
}

Zugriff auf Elemente

// Der Index darf nicht außerhalb der Größe des Arrays sein!
int[] zahlenstrahl = new int[100];

int erstesElement = zahlenstrahl[0];
int beliebigesElement = zahlenstrahl[42];
int zahl = zahlenstrahl[101];   // Fehler, da die maximale Arraygröße 100 ist

// Zugriff auf jedes Element im Array
int element;
for (int element : beispielarray ) {
  System.out.print(element + " ");
}

Maximum - Minimum bestimmen

double maximum = Double.MIN_VALUE;  // oder Double.MAX_VALUE bei Minimum
for (int e : a) {
  if (e > minimum) {
    maximum = e;
  }
}

Durchschnittsberechnung

double durchschnitt = 0;
for (int e : a) {
  durchschnitt = durchschnitt +  e;
  }
}
durchschnitt = durchschnitt / a.length;

Mehrdimensionale Arrays

Ein Array kann mehrere Dimensionen haben. Ein zweidimensionales Array entspricht einem Array, dessen Elemente wieder Arrays sind. Dieses Prinzip lässt sich auf beliebig viele Dimensionen übertragen.

Allgemeine Form

// Die Anzahl der eckigen Klammern entspricht den Dimensionen
datentyp[][] a = new datentyp[Anzahl][Anzahl];            // 2 Dimensionen
datentyp[][][] a = new datentyp[Anzahl][Anzahl][Anzahl];  // 3 Dimensionen

datentyp[][] a = new datentyp[3][4];
Ein zweidimensionales Array (3 Zeilen × 4 Spalten)

[0][0]	[0][1]	[0][2]	[0][3]
[1][0]	[1][1]	[1][2]	[1][3]
[2][0]	[2][1]	[2][2]	[2][3]

Direkte Deklaration und Zuweisung

// int[][] dimensionen = new int[4][2];
// dimensionen[0][0] = 5;
// dimensionen[0][1] = 2;
// ...
int[][] dimensionen = { { 5, 2}, { 124, 5}, { 42, 42}, { 25, 24}};

Zugriff auf Elemente

// Zugriff immer nur auf ein Element
int[][] matrix = new int[5][5];
matrix[0][0] = 10;
matrix[2][4] = 20;
matrix[4][1] = 30;

// Zugriff auf jedes Element im Array
int[][] meinarray = new int[10][20];
for (int i = 0; i < 10; i++) {
  for (int k = 0; k < 20; k++) {
    System.out.print(meinarray[i][k] + " ");
  }
}

Java Insel

​Arrays