Literatur

Arrays

Eindimensionale Arrays

Eindimensionale Arrays (deutsch: Felder) sind im Prinzip einfache Listen. Diese Arrays werden mit einem Datentypen deklariert, d.h. alle Werte, die in diesem Array gespeichert werden sollen, müssen von demselben Datentyp sein, mit dem das Array deklariert wurde.

Das Array erhält außerdem eine festgelegte unveränderbare Größe, die in dem Attribut length gespeichert wird und zur Laufzeit abfragbar ist. Wird bei einem Array z.B. auf ein elftes Element zugegriffen und das Array wurde aber nur mit einer Länge von zehn deklariert, so wird eine sogenannte java.lang.ArrayIndexOutOfBoundsException (Ausnahme) geworfen. Da Exceptions erst in einem späteren Artikel behandelt werden, soll hier nur kurz erwähnt werden, dass Exceptions geworfen werden, wenn während der Laufzeit eines Programms eine Ausnahme (in diesem Fall der Zugriff auf ein nicht-vorhandenes Element des Arrays) auftritt.

Kennzeichnend für ein Array sind die eckigen Klammern. Diese können wahlweise zwischen Datentyp und Arrayname oder nach dem Arraynamen stehen. Da es sich bei einem Array um einen komplexen Datentyp handelt, benötigt man bei der Erzeugung des Arrays den new-Operator.

Datentyp [ ] Arrayname = new Datentyp[Länge];  /* Syntax für die Deklaration eines Arrays */
Datentyp  Arrayname [ ] = new Datentyp[Länge];  /* Syntax für die Deklaration eines Arrays */

Um ein bestimmtes Element des Arrays ansprechen zu können, hat jedes Element eine Nummer, den sogenannten Index. Das erste Element bekommt den Index 0, das zweite den Index 1 usw.  Mit folgender Syntax weist man einem Element des Arrays einen Wert zu:

Arrayname[Index] = Wert;   /* Syntax für die Initialisierung eines Feldelementes */

Mit der sogenannten Initialisierungsliste ist es aber auch möglich, bereits bei der Erstellung des Arrays den Elementen in einem Schritt sofort Werte zuzuweisen. Hier ist dann kein new-Operator erforderlich.

Datentyp [ ] Arrayname = {Element 0, Element 1, Element 2, Element n-1, Element n};   /* Syntax für die Literalinitialisierung eines Arrays */

Sehen wir uns dazu ein Beispiel an:

Beispiel:

int [ ] arr1=new int[5];   /* Erzeugung eines Arrays mit der Feldgröße 5 */
int [ ] arr2 = {1,2,3,4,5};   /* Initialisierungsliste eines Arrays mit der Länge 5 */


In dem obigen Beispiel haben wir mit dem new-Operator ein Array erzeugt, das die Größe 5 hat und dessen Elemente vom Datentyp int sind. Das Array enthält jedoch noch keine Werte. Die zweite Erzeugung erfolgt über die  Initialisierungsliste. Dabei wird direkt jedes Feld-Element eines Arrays mit einem Wert belegt.

Um auf ein Element zuzugreifen, muss nach dem Array-Namen in eckigen Klammer der Index des Elementes angegeben werden.

Beispiel:

String [ ] namen= {"Gustaf", "Hans", "Klaus", "Maria", "Gustaf"};  /* Initialisierungsliste eines String-Arrays */
String name = namen[3];   /* Element an der Position 3 wird in der Variablen name gespeichert (hier: "Maria") */

In der ersten Zeile erzeugen wir durch Initialisierungsliste ein String-Array mit fünf Namen. In der zweiten Zeile speichern wir das Element mit dem Index 3 in der Variablen name ab. In diesem Fall enthält die Variable den Namen "Maria" (Nicht vergessen: Wir fangen bei 0 an zu zählen!).

 

Mehrdimensionale Arrays

In Java kann man aber auch mehrdimensionale Arrays erstellen. Bei diesen handelt es sich um ineinander geschachtelte Arrays: Die Elemente der ersten Dimension sind Arrays, die selber wieder Arrays der zweiten Dimension enthalten usw. Jede Dimension wird durch ein Paar eckiger Klammern dargestellt.  In einem zweidimensionalen Array lassen sich zum Beispiel Daten aus einer Tabelle ablegen. Das erste Klammernpaar könnte dann z.B. für die Zeile, das zweite für die Spalte stehen.

Beispiel:

double [ ] [ ] tabelle = new double [20] [10];   /* Tabelle mit Elementen vom Typ double mit 20 Zeilen und 10 Spalten */

Bei der Wertzuweisung  oder dem Zugriff auf ein Element müssen alle Indizes angegeben werden

Beispiel:

tabelle[11][3] = 2.74;    


Auch eine Initialisierungsliste ist hier wieder möglich

Beispiel:

int zahlenArr [ ] [ ]  = { {4,7,2}, {8,5,3,1}, {6,9}, {3,6,4} };

Bei der Objekt-Erzeugung eines mehrdimensionalen Arrays muss mindestens die Größe der ersten Dimension bekannt sein.

Das Attribut length gibt immer die Größe der aktuellen Dimension an. Wenn sie ein Element auf unterster Ebene ansprechen wollen, dann müssen die Indizes aller Dimensionen komplett angegeben werden.

Beispiel:

double zeile [ ] = tabelle[5];  /* da der zweite Index für die Spalte nicht angegeben wurde,  wird die gesamte sechste "Tabellenzeile"  als Array ausgelesen */
double wert = tabelle[5][3];  /* hier wird der Inhalt einer einzelnen Zelle der Tabelle ausgelesen */

 

Schauen wir uns dazu außerdem drei kleine Übungen an, bei denen Sie darüber nachdenken können, ob die Beispiele so richtig sind oder nicht. Zu jedem Beispiel gibt es eine Schaltfläche, um die Lösung zu erfahren.

 Übung 1:

int matrix [ ][ ][ ][ ] = new int [1][11][12][ ];  /* vierdimensionales Array, wobei die ersten drei Dimensionen bekannt  sind  */
int länge= matrix[0][0].length;  /* Die Größe welcher Dimension wird in die Variable länge gespeichert? */




Übung 2:

int matrix [ ][ ][ ][ ] = new int [1][ ][12][ ];  /* vierdimensionales Array, wobei die erste und die dritte Dimension bekannt sind */




Übung 3:

int matrix [ ][ ][ ][ ] = new int [ ][ ][ ][ ];  /* vierdimensionales Array, wobei keine Dimensionen bekannt ist */

 

Der Code aus Übung 1 ist zwar möglich, aber wenig praktikabel. Der folgende Aufwand zur vollständigen Initialisierung ist immens. Wir zeigen nun an einem kleinen Code-Beispiel nur die Initialisierung eines einzelnen Feldes der vierten Dimension.

int matrix [ ][ ][ ][ ] = new int [1][11][12][ ];  /*  vierdimensionales Array, wobei die ersten drei Dimensionen bekannt sind */
matrix[0][0][0] = new int[10];  /* Initialisierung eines Feldes der vierten Dimension, wobei der Index der ersten drei Dimensionen 0 ist */

Wenn Sie im Nachhinein die vierte Dimension komplett initialisieren möchten, müssten Sie also in diesem Beispiel eine dreifach geschachtelte for-Schleife implementieren. Daher kennt man am besten alle Dimensionen direkt bei der ersten Initialisierung. Zur Abschreckung zeigen wir einmal den Aufwand für die Initialisierung mit einer dreifachgeschachtelten for-Schleife.

 
int matrix[ ][ ][ ][ ] = new int[1][11][12][ ];
 
for (int i = 0; i < matrix.length; i++)
{
        for (int j = 0; j < matrix[i].length; j++)
        {
            for (int k = 0; k < matrix[i][j].length; k++)
            {
                  matrix[i][j][k] = new int[10];  /* Initialisierung eines Feldes der vierten Dimension */
            }
        }
}
 

Wie Sie sehen, muss für jede Feldposition ein neues Array erzeugt werden. In unserem Beispiel bekommt jedes Feld der vierten Dimension die Größe 10 zugewiesen.