Java-Grundlagen: Arrays in Java – Deklaration, Initialisierung und Zugriff auf Arrays

Arrays werden benutzt, um mehrere Elemente eines Datentyps in einer Reihe zusammenzufassen. Diese Aneinanderreihung kann auch mehrdimensional erfolgen.

Arrays sind ein elementarer Bestandteil der Programmiersprache Java. Sie werden vom Java-Compiler erzeugt und während der Laufzeit wie normale Java-Objekte behandelt. Wobei für die Initialisierung von Arrays der new-Operator nicht benötigt. Die Länge eines Array-Objekts kann über die öffentliche Instanzvariable length ausgelesen werden.

Da in Java Arrays Objekte sind, ergeben sich daraus folgende Eigenschaften:

• Arrays besitzen Methoden und Instanz-Variablen
• Eine Array-Variable ist immer eine Referenz und verweist auf das Array-Objekt
• Während der Laufzeit werden Arrays wie Objekte behandelt

Die Größe von Arrays kann nicht im Nachhinein verändert werden. Sie muss zwar nicht bei der Deklaration vorgegeben werden, sondern kann während der Laufzeit festgelegt werden. Ab diesem Zeitpunkt ist die Array-Größe dann aber nicht mehr änderbar. Daher sind Arrays semi-dynamisch.

Deklaration und Initialisierung von Arrays in Java

Ein Array wird wie eine normale Variable deklariert. Die Syntax entspricht fast der Standard-Deklaration bis auf die eckigen Klammern nach dem Variablentyp.

In der folgenden Beispielanwendung werden mehrere Array-Objekte beispielhaft deklariert und initialisiert. Ihr sollt dadurch ein besseres Gefühl für den Ungang mit Arrays bekommen.

Beispielanwendung Deklaration von Array-Variablen in Java.

/*
* Beispielanwendung Deklaration von Array-Variablen in Java.
*/

import java.util.Arrays;

public class ArrayDeklaration{
    public static void main(String[] args) {
        System.out.println("\n1: Deklarieren der Array-Variablen");

        int[] a;
        a = new int[3];   

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

        int[] c = {1,2,3};

        int[] d = new int[] {8,4,2,1};

        System.out.println("\n2: Ausgabe der Array-Werte\n");
        System.out.println("a1a2a3:   " + a[0] + a[1] + a[2]);
        System.out.println("b1b2b3b4: " + b[0] + b[1] + b[2] + b[3]);
        System.out.println("c1c2c3:   " + c[0] + c[1] + c[2]);
        System.out.println("d1d2d3d4: " + d[0] + d[1] + d[2] + d[3]);

        boolean[] boo    = {true, true, false};
        char[] cha = {'a', 'b', 'c'};
        float[]  flo  = {3.01f, -.5e-1F, 4.6e+4f};

        System.out.println("\nboo: " + boo[0] + boo[1] + boo[2]);
        System.out.println("cha: " + cha[0] + cha[1] + cha[2]);
        System.out.println("\nflo[0]: " + flo[0]);
        System.out.println("flo[1]: " + flo[1]);
        System.out.println("flo[2]: " + flo[2]);

        String[] zeichenkette   = {"Hallo PLHQ", "Willkommen in Java"};
        System.out.println("\nzeichenkette: " + Arrays.toString(zeichenkette));
    }
}

In Zeile 11 wird das Array-Objekt a mit der Anweisung int[] a; deklariert. Besondere Beachtung verdienen die eckigen Klammern [] hinter dem Variablentyp int. Aufgrund der eckigen Klammern weiß der Java-Compiler, dass es sich bei Variable a um ein Array-Objekt vom Typ int handelt.

Zu diesem Zeitpunkt (nach der Deklaration) ist die Länge des Arrays noch unbestimmt, d.h. es wurde noch nicht festgelegt aus wievielen Elementen der Array besteht.

Anschließend wird in Zeile 12 das Array-Objekt a mit der Anweisung a = new int[3]; initialisiert. Dabei wird ein Array-Objekt mit 3 Elementen vom Typ int mit Hilfe des new-Operators erstellt. Jedem dieser Elemente wird der Standard int-Wert 0 zugewiesen.

Zu diesem Zeitpunkt (nach der Initialisierung) ist die Länge des Arrays bestimmt und zwar besteht das Array-Objekt a aus den 3 Elementen a[0], a[1] und a[2].

In Zeile 14 wird Deklaration und Initialisierung in einem Schritt ausgeführt, mit der Anweisung int[] b = new int [4];. Anschließend werden die 4 erstellten Array-Elemente mit Inhalt gefüllt, dies geschieht durch die Anweisungen in Zeile 15 bis Zeile 18.
Mit der Anweisung b[0] = 0; wird dem 1. Array-Element des Array-Objekts b der int-Wert 0 zugewiesen.

Hinweis: Das Array-Objekt b besitzt 4 Elemente, auf die mit den Anweisungen b[0], b[1], b[2] und b[3] zugegriffen wird. Unbedingt beachten! Es gibt keine Element b[4], obwohl das Array-Objekt mit der Anweisung int[] b = new int [4]; erzeugt wurde. Das liegt daran, dass Arrays immer mit dem 0. Element b[0] beginnen. Somit ist Element b[1] bereits das zweite Element und Element b[2] das dritte und b[3] das letzte Element.

Da bei der Initialisierung von Arrays der new-Operator nicht benötigt wird, kann man mit der Anweisung int[] c = {1,2,3}; aus Zeile 20 eine Array-Variable direkt mit Werten füllen. Es gibt noch eine umfangreichere Anweisung, die jedoch das gleiche Ergebnis erzielt. In Zeile 22 ist dafür ein Beispiel angegeben: int[] d = new int[] {8,4,2,1};.

In beiden Fällen wird der Array literal initialisiert, durch Auflisten der Array-Elemente in geschweiften Klammern. Die Array-Läne ergibt sich aus der Anzahl der zugewiesenen Elemente. Die literale Initialisierung muss in einem Schritt zusammen mit der Array-Deklaration erfolgen.

In den Zeilen 25 bis 28 wird der Inhalt der Array-Objekte a, b, c und d auf der Kommandozeile ausgegeben. Auf ein bestimmtes Element n eines Array-Objekts a wird mit der Anweisung a[n] zugegriffen. Auf diese Weise werden die Werte der einzelnen Elemente ausgelesen. Der numerische Index n kann dabei die Werte zwischen 0 und Arraylänge-1 annehmen und muss von Typ int sein.

Die Array-Grenzen werden vom Laufzeitsystem überwacht. Der numerische Index n muss innerhalb dieser Grenzen liegen, d.h. größer als 0 und kleiner als die Instanzvariable des Array-Objekts length, die der Länge des Arrays entspricht, sein.

In den Zeilen 30 bis 32 werden drei weitere Array-Objekte erzeugt, diesmal aber nicht vom Typ int, sondern boolean, char und float. Die Deklaration und Initialisierung läuft nach dem selben Schema ab. Bei dem Füllen der Array-Elemente muss darauf geachtet werden die korrekten Literale zu verwenden:

• bei boolean: true und false
• bei char: ‚a‘, ‚b‘, usw.
• bei float: 3.01f, -.5e-1F oder 4.6e+4f

In den Zeilen 34 bis 38 wird der Inhalt der Array-Objekte boo, cha und flo auf der Kommandozeile ausgegeben.

Bisher haben wir nur Arrays erstellt, die Elemente der primitiven Datentypen (logischer, integraler, Gleitkomma- und Zeichen-Datentyp) besitzen. Array-Objekte können aber auch Elemente enthalten, die selbst wieder Objekte sind.

In Zeile 40 wird das Array-Objekt zeichenkette deklariert und mit 2 String-Objekten gefüllt. Anschließend wird in Zeile 41 der Inhalt des Array-Objekts zeichenkette auf der Kommandozeile mit Hilfe der Methode toString() ausgegeben.

In der unteren Abbildung ist die Kommandozeilen-Ausgabe zu der oberen Beispielanwendung dargestellt.

Deklaration und Initialisierung von mehrdimensionalen Arrays in Java

Die Deklaration von mehrdimensionalen Arrays erfolgt über das Aneinanderreihen mehrerer eckiger Klammernpaare. Jedes Klammernpaar repräsentiert dabei eine Dimension. Bei der Initialisierung werden die Anzahl der Elemente je Dimension festgelegt.

In der folgenden Beispielanwendung werden 3 mehrdimensionale Array-Objekte deklariert und initialisiert.

Beispielanwendung Deklaration von mehrdimensionalen Array-Variablen in Java.

/*
* Beispielanwendung Deklaration von mehrdimensionalen Array-Variablen in Java.
*/

import java.util.Arrays;

public class ArrayDeklarationMehrdimensional{
    public static void main(String[] args) {
        System.out.println("\n1: Deklarieren der Array-Variablen");

        int[][][] a = new int[2][1][2];
        a[0][0][0] = 0b000;
        a[0][0][1] = 0b001;
        a[1][0][0] = 0b100;
        a[1][0][1] = 0b101; 
        
        int[][] b = { {1}, {1,2,1}, {1,2,3,2,1}, {1,2,3,4,3,2,1},
                      {1,2,3,2,1}, {1,2,1}, {1} };
        int[] c1 = {1};
        int[] c2 = {1,2,1};
        int[] c3 = {1,2,3,2,1};
        int[] c4 = {1,2,3,4,3,2,1};
        int[][] c = {c1,c2,c3,c4,c3,c2,c1};


        System.out.println("\n2: Ausgabe der Array-Werte\n");

        System.out.println("\nRechteckiger Array a:");
        System.out.println("a000: " + a[0][0][0]);
        System.out.println("a001: " + a[0][0][1]);
        System.out.println("a100: " + a[1][0][0]);
        System.out.println("a101: " + a[1][0][1]);

        System.out.println("\nNichtrechteckiger Array b:");
        for (int i=0; i<b.length; i++) {
           for (int j=0; j<b[i].length; j++) {
               System.out.print(b[i][j]);
           }
        System.out.println();
        }
     
        System.out.println("\nNichtrechteckiger Array c:");
        for (int i=0; i<c.length; i++) {
           for (int j=0; j<c[i].length; j++) {
               System.out.print(c[i][j]);
           }
        System.out.println();
        }

    }
}

In dem oberen Quellcode-Beispiel wird in Zeile 11 das dreidimensionale Array-Objekt a mit der Anweisung int[][][] a = new int[2][1][2]; deklariert und sogleich initialisiert. Die Größe des Arrays ergibt sich aus der Anzahl seiner Elemente 2x1x2 = 4 Elemente.

Anschließend werden in den Zeilen 12 bis 15 den Array-Elementen integer-Werte zugewiesen. Dabei wird die binäre Schreibweise verwendet, die in Java 7 eingeführt wurde. Siehe folgender Beitrag: Java-Grundlagen: Die 2 Datentypenarten in Java und ihre Verwendung.

In Zeile 17 wird der zweidimensionale nichtrechteckige Array b mit Hilfe der literalen Initialisierung erzeugt. Dabei werden die geschweiften Klammernpaare ineinander geschachtelt. Da mehrdimensionale Arrays als Arrays von Arrays angelegt werden, ist es möglich, nichtrechteckige Arrays zu erstellen.

Dies wird anhand der Anweisungen in den Zeilen 19 bis 23 ersichtlich. Zuerst werden 4 eindimensionale Array-Objekte c1, c2, c3 und c4 erzeugt, anschließend werden dem zweidimensionalen Array c die eindimensionalen Array-Objekte als Elemente zugewiesen.

In den Zeilen 28 bis 48 werden die Elemente der erstellten Arrays auf der Kommandozeile ausgegeben. Der Zugriff auf die Elemente der mehrdimensionale Arrays erfolgt durch Angabe aller erforderlichen Indizes, jeweils in eigenen eckigen Klammern. Die beiden verschachtelten for-Schleifen wollen wir hier nicht weiter besprechen. Im Moment reicht es zu wissen, dass über sie der Inhalt der nichtrechteckigen Arrays b und c ausgegeben wird.

In der unteren Abbildung ist die Kommandozeilen-Ausgabe zu der Beispielanwendung für mehrdimensionale Arrays dargestellt.

---