Arrays

Typische Probleme

Wie bildet man das Minimum von 100 Werten?

Wie speichert man die Matrikelnummern der 90 Teilnehmer unserer Vorlesung?

Gemeinsamkeit

viele unterschiedliche Werte desselben Datentyps
Anzahl der Werte ist im Voraus bekannt

Man verwendet Arrays, um mehrere Werte gleichen Typs effizient unter einem gemeinsamen Namen zu speichern. Sie sind besonders dann nützlich, wenn man mit einer festen Anzahl von Elementen arbeiten möchte, zum Beispiel eine Liste von Zahlen, Zeichen oder Objekten.

Ohne Arrays müsste man für jeden Wert eine eigene Variable deklarieren, was unübersichtlich und unpraktisch wäre, besonders bei vielen Werten. Arrays ermöglichen es, mit Schleifen auf die Elemente zuzugreifen, sie zu verarbeiten oder zu durchsuchen. Sie bieten damit eine einfache Möglichkeit, Datenmengen systematisch zu verwalten, z. B. beim Berechnen von Durchschnittswerten, beim Sortieren oder beim Speichern von Benutzereingaben.

Array

Ein Array oder Feld ist ein zusammenhängender Speicherbereich, der aus N Speicherzellen besteht, die alle den gleichen Datentyp enthalten.
nach G. Büchel, Praktische Informatik

Arrays

sind ein höherer Datentyp, d. h. sie sind aus einfacheren Datentypen aufgebaut
sind Referenzdatentypen (wird später erklärt)
haben eine feste Größe, die nicht mehr geändert werden kann

Elemente des Arrays

werden über ihre Position (Index) angesprochen
Index beginnt bei 0

Array als höherer Datentyp

Die einzelnen Elemente eines Arrays werden kompakt, d. h. direkt hintereinander abgelegt. Dies ermöglicht einen einfachen Zugriff auf die einzelnen Elemente, weil man die Position im Speicher einfach nach der Formel

\[ \begin{align*} \text{Addresse} = \text{Anfangsadresse} + \text{Index} \cdot \text{Größe des Datentyps} \end{align*} \]

Dies erklärt auch, warum man die Indices bei 0 beginnen lässt, weil hierdurch die Berechnung einfacher ist.

Die Größe des Datentyps wird in Byte gemessen und ist für jeden Datentyp in Java eindeutig festgelegt:

Datentyp	Größe (in Byte)
`boolean`	abhängig von VM
`byte`	1
`char`	2
`short`	2
`int`	4
`long`	8
`float`	4
`double`	8

Die Anfangsadresse ergibt sich aus der Referenz, die auf das Array zeigt. Anders als in anderen Programmiersprachen (z. B. C) beginnen die Datend es Arrays nicht direkt an der Adresse, auf welche die Referenz zeigt, sondern es gibt noch ein paar Daten fester Länge am Anfang, insbesondere die Information zur Länge des Arrays. Damit ist die korrekte Formel für den Zugriff auf ein Element

\[ \begin{align*} \text{Addresse} = \text{Anfangsadresse} + \text{Größe der Kopfdaten} + \text{Index} \cdot \text{Größe des Datentyps} \end{align*} \]

Deklaration von Arrays

Syntax

Variablendeklaration: DATENTYP[] variable;
Speicherbeschaffung: variable = new DATENTYP[GROESSE];
Wertzuweisung: variable[INDEX] = WERT;
Wert auslesen: variable[INDEX]
Auslesen der Länge eines Arrays: variable.length

Indizes (INDEX) beginnen bei 0 und laufen bis length - 1

Variablendeklaration

DATENTYP[] variable;

Bei der Deklaration eines Arrays gibt man an, welchen Datentyp die Elemente des Arrays haben sollen. Das Symbol [] zeigt an, dass es sich um ein Array handelt. Es wird dabei lediglich die Referenzvariable deklariert und es wird noch kein Speicherplatz für die eigentlichen Elemente reserviert.

int[] zahlen;

Hier wird eine Array-Variable zahlen deklariert, die später auf ein Array von Ganzzahlen (int) zeigen soll.

Speicherbeschaffung

variable = new DATENTYP[GROESSE];

In diesem Schritt wird der Speicher für das Array reserviert. Mit dem Schlüsselwort new erzeugt man ein neues Array mit der angegebenen Größe. Dabei wird Speicher für die einzelnen Array-Elemente bereitgestellt, und diese werden mit den Standardwerten (s. o.) für den jeweiligen Datentyp initialisiert.

zahlen = new int[5];

Jetzt verweist zahlen auf ein Array mit fünf Ganzzahlen, die zunächst alle den Wert 0 haben (Standardwert für int).

Wertzuweisung

variable[INDEX] = WERT;

Man kann einem bestimmten Array-Element einen Wert zuweisen, indem man seinen Index angibt. Der Index beginnt bei 0, das heißt, das erste Element hat den Index 0, das zweite den Index 1 usw.

zahlen[2] = 10;

Hier wird dem dritten Element des Arrays (Index 2) der Wert 10 zugewiesen.

Wert auslesen

variable[INDEX]

Ein bestimmter Wert kann durch Angabe des Index direkt aus dem Array gelesen werden. Man greift also auf das entsprechende Array-Element an der Position, die durch den Index bestimmt wird, zu.

int x = zahlen[2];

Der Wert an Index 2 (in unserem Fall 10) wird aus dem Array gelesen und der Variablen x zugewiesen.

Auslesen der Länge eines Arrays

variable.length

Jedes Array besitzt ein Attribut length, über das man die Größe (Anzahl der Elemente) des Arrays abfragen kann. Dies ist besonders nützlich, wenn man Schleifen über das Array schreiben möchte.

int anzahl = zahlen.length;

Hier wird der Wert 5 (die Länge des Arrays zahlen) in die Variable anzahl gespeichert.

Initialisierung von Arrays

Nach dem Anlegen des Arrays mit new haben die Elemente Standardwerte (default values)

boolean → false
byte, short, char, int, long → 0
double, float → 0.0
alle Referenztypen → null

int[] array = new int[3];
System.out.println(array[2]); // --> 0

Wenn beim Anlegen bereits alle Elemente bekannt sind: Initialisierung über Array-Literal
DATENTYP[] variable = { WERT1, WERT2, WERT3 };

int[] primzahlen = { 2, 3, 5, 7, 11, 13, 17, 19 };

String[] wochentage = { "Montag", "Dienstag", "Mittwoch",
        "Donnerstag", "Freitag", "Samstag", "Sonntag" };

int[] leeresArray = {};

Mehrdimensionale Arrays

Mehrdimensionale Arrays

Arrays können beliebig viele Dimensionen haben, häufig zwei
mehrdimensionale Arrays werden durch Arrays realisiert, die wieder Referenzen auf Arrays enthalten

int[][] matrix = { { 3, 7 }, { 6, 2 }, { 0, 8 }, { 4, 5 }, { 7, 4 } };

System.out.println(matrix.length); // -> 5
System.out.println(matrix[0].length); // -> 2

System.out.println(matrix[1][1]); // -> 2
System.out.println(matrix[4][0]); // -> 7

In Java werden mehrdimensionale Arrays als Arrays von Arrays realisiert. Das bedeutet, ein zweidimensionales Array ist eigentlich ein Array, dessen Elemente wiederum Arrays sind. Diese Struktur erlaubt auch sogenannte „unregelmäßige“ Arrays, bei denen die inneren Arrays unterschiedlich lang sein können.

int[][] matrix = new int[3][4];

Hier wird ein 2D-Array mit 3 Zeilen und 4 Spalten erstellt, also ein rechteckiges Array.

Man kann aber auch:

int[][] jagged = new int[3][];
jagged[0] = new int[2];
jagged[1] = new int[4];
jagged[2] = new int[1];

Hier hat jede Zeile eine andere Länge, etwas, das in Java problemlos möglich ist.

In anderen Programmiersprachen (z. B. C) sind mehrdimensionale Arrays typischerweise zusammenhängende Speicherblöcke, bei denen alle Elemente flach im Speicher angeordnet sind. Das bedeutet, C behandelt ein int[3][4] als ein Block mit 12 int-Werten, und der Zugriff erfolgt über eine Adressberechnung.

Syntax

Variablendeklaration: DATENTYP[][] variable;
Speicherbeschaffung: variable = new DATENTYP[GROESSE1][GROESSE2];
Wertzuweisung: variable[INDEX1][INDEX2] = WERT;
Wert auslesen: variable[INDEX1][INDEX2]
Auslesen der Länge der ersten Dimension: variable.length
Auslesen der Länge der zweiten Dimension: variable[INDEX].length

Variablendeklaration

DATENTYP[][] variable;

Hier wird eine Referenzvariable für ein zweidimensionales Array deklariert. Der Datentyp legt fest, welche Art von Daten im Array gespeichert werden, zum Beispiel int, double, String usw. Die beiden eckigen Klammern [][] zeigen an, dass es sich um ein zweidimensionales Array handelt, also ein Array von Arrays.

Beispiel:

int[][] matrix;

Dies deklariert eine Variable matrix, die auf ein zweidimensionales Array von Ganzzahlen zeigen kann.

Speicherbeschaffung

variable = new DATENTYP[GROESSE1][GROESSE2];

In diesem Schritt wird dem Array tatsächlich Speicher zugewiesen. Mit dem new-Operator wird ein zweidimensionales Array mit einer bestimmten Anzahl von Zeilen (GROESSE1) und Spalten (GROESSE2) erzeugt. Jedes Element wird dabei automatisch mit dem Standardwert des Datentyps initialisiert.

Beispiel:

matrix = new int[3][4];

Dies erstellt ein Array mit 3 Zeilen und 4 Spalten, also insgesamt 12 Ganzzahlen mit dem Anfangswert 0.

Wertzuweisung

variable[INDEX1][INDEX2] = WERT;

Hier wird einem bestimmten Element des Arrays ein Wert zugewiesen. Mit INDEX1 wird die Zeile und mit INDEX2 die Spalte angegeben.

Die Indizes beginnen wie üblich bei 0.

Beispiel:

matrix[1][2] = 7;

Das bedeutet: In der zweiten Zeile (Index 1) und der dritten Spalte (Index 2) wird der Wert 7 gespeichert.

Wert auslesen

variable[INDEX1][INDEX2]

Ein einzelner Wert kann direkt mit den entsprechenden Indizes aus dem Array ausgelesen werden.

Beispiel:

int x = matrix[1][2];

Der Inhalt der Zelle in Zeile 2, Spalte 3 wird ausgelesen und der Variablen x zugewiesen.

Auslesen der Länge der ersten Dimension

variable.length

Mit dieser Anweisung kann man die Anzahl der Zeilen (also die erste Dimension) des Arrays abfragen.

Beispiel:

int zeilen = matrix.length;

Hier wird zeilen der Wert 3 zugewiesen, wenn das Array matrix wie oben deklariert wurde (new int[3][4]).

Auslesen der Länge der zweiten Dimension

variable[INDEX].length

Da ein zweidimensionales Array in Java als ein Array von Arrays implementiert ist, kann jede Zeile unterschiedlich viele Spalten haben.

Mit variable[INDEX].length fragt man die Anzahl der Spalten in der angegebenen Zeile ab.

Beispiel:

int spalten = matrix[0].length;

Hier wird die Anzahl der Spalten in der ersten Zeile (Index 0) gespeichert – im Beispiel also 4.