Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 4 - Datentypen

## 4.4 Arrays

- 4.4 Arrays
  - 4.4.1 Deklaration und Initialisierung
  - 4.4.2 Zugriff auf Array-Elemente
  - 4.4.3 Mehrdimensionale Arrays

Arrays in Java unterscheiden sich dadurch von Arrays in anderen Programmiersprachen, daß sie Objekte sind. Obwohl dieser Umstand in vielen Fällen vernachlässigt werden kann, bedeutet er dennoch:

- daß Array-Variablen Referenzen sind
- daß Arrays Methoden und Instanz-Variablen besitzen
- daß Arrays zur Laufzeit erzeugt werden

|  | Dennoch bleibt ein Array immer eine (möglicherweise mehrdimensionale) Reihung von Elementen eines festen Grundtyps. Arrays in Java sind semidynamisch, d.h. ihre Größe kann zur Laufzeit festgelegt, später aber nicht mehr verändert werden. |  |
Hinweis

### 4.4.1 Deklaration und Initialisierung

Die Deklaration eines Arrays in Java erfolgt in zwei Schritten:

- Deklaration einer Array-Variablen
- Erzeugen eines Arrays und Zuweisung an die Array-Variable

Die Deklaration eines Arrays entspricht syntaktisch der einer einfachen Variablen, mit dem Unterschied, daß an den Typnamen eckige Klammern angehängt werden:

    001 int[] a;
    002 double[] b;
    003 boolean[] c;

Listing 4.4: Deklaration von Arrays

|  | Wahlweise können die eckigen Klammern auch hinter den Variablennamen geschrieben werden, aber das ist ein Tribut an die Kompatibilität zu C/C++ und sollte in neuen Java-Programmen vermieden werden. |  |
Hinweis

Zum Zeitpunkt der Deklaration wird noch nicht festgelegt, wie viele Elemente das Array haben soll. Dies geschieht erst später bei seiner Initialisierung, die mit Hilfe des `new`-Operators oder durch Zuweisung eines Array-Literals ausgeführt wird. Sollen also beispielsweise die oben deklarierten Arrays 5, 10 und 15 Elemente haben, würden wir das Beispiel wie folgt erweitern:

    001 a = new int[5];
    002 b = new double[10];
    003 c = new boolean[15];

Listing 4.5: Erzeugen von Arrays

Ist bereits zum Deklarationszeitpunkt klar, wie viele Elemente das Array haben soll, können Deklaration und Initialisierung zusammen geschrieben werden:

    001 int[] a = new int[5];
    002 double[] b = new double[10];
    003 boolean[] c = new boolean[15];

Listing 4.6: Deklaration und Initialisierung von Arrays

Alternativ zur Verwendung des `new`-Operators kann ein Array auch literal initialisiert werden. Dazu werden die Elemente des Arrays in geschweifte Klammern gesetzt und nach einem Zuweisungsoperator zur Initialisierung verwendet. Die Größe des Arrays ergibt sich aus der Anzahl der zugewiesenen Elemente:

    001 int[] x = {1,2,3,4,5};
    002 boolean[] y = {true, true};

Listing 4.7: Initialisierung mit literalen Arrays

Das Beispiel generiert ein `int`-Array `x` mit fünf Elementen und ein `boolean`-Array `y` mit zwei Elementen. Anders als bei der expliziten Initialisierung mit `new` muß die Initialisierung in diesem Fall unmittelbar bei der Deklaration erfolgen.

### 4.4.2 Zugriff auf Array-Elemente

Bei der Initialisierung eines Arrays von `n` Elementen werden die einzelnen Elemente von `0` bis `n-1` durchnumeriert. Der Zugriff auf jedes einzelne Element erfolgt über seinen numerischen Index, der nach dem Array-Namen in eckigen Klammern geschrieben wird. Das nachfolgende Beispiel deklariert zwei Arrays mit Elementen des Typs `int` bzw. `boolean`, die dann ausgegeben werden:

    001 /* Listing0408.java */
    002
    003 public class Listing0408
    004 {
    005   public static void main(String[] args)
    006   {
    007     int[] prim = new int[5];
    008     boolean[] b = {true,false};
    009     prim[0] = 2;
    010     prim[1] = 3;
    011     prim[2] = 5;
    012     prim[3] = 7;
    013     prim[4] = 11;
    014
    015     System.out.println("prim hat "+prim.length+" Elemente");
    016     System.out.println("b hat "+b.length+" Elemente");
    017     System.out.println(prim[0]);
    018     System.out.println(prim[1]);
    019     System.out.println(prim[2]);
    020     System.out.println(prim[3]);
    021     System.out.println(prim[4]);
    022     System.out.println(b[0]);
    023     System.out.println(b[1]);
    024   }
    025 }
| Listing0408.java

Listing 4.8: Deklaration und Zugriff auf Arrays

Die Ausgabe des Programms ist:

    prim hat 5 Elemente
    b hat 2 Elemente
    2
    3
    5
    7
    11
    true
    false

|  |  |  | Der Array-Index muß vom Typ `int` sein. Aufgrund der vom Compiler automatisch vorgenommenen Typkonvertierungen sind auch `short`, `byte` und `char` zulässig. Jedes Array hat eine Instanzvariable `length`, die die Anzahl seiner Elemente angibt. Indexausdrücke werden vom Laufzeitsystem auf Einhaltung der Array-Grenzen geprüft. Sie müssen größer gleich 0 und kleiner als `length` sein. |  |
Tip

### 4.4.3 Mehrdimensionale Arrays

Mehrdimensionale Arrays werden erzeugt, indem zwei oder mehr Paare eckiger Klammern bei der Deklaration angegeben werden. Mehrdimensionale Arrays werden als Arrays von Arrays angelegt. Die Initialisierung erfolgt analog zu eindimensionalen Arrays durch Angabe der Anzahl der Elemente je Dimension.

Der Zugriff auf mehrdimensionale Arrays geschieht durch Angabe aller erforderlichen Indizes, jeweils in eigenen eckigen Klammern. Auch bei mehrdimensionalen Arrays kann eine literale Initialisierung durch Schachtelung der Initialisierungssequenzen erreicht werden. Das folgende Beispiel erzeugt ein Array der Größe 2 * 3 und gibt dessen Elemente aus:

    001 /* Listing0409.java */
    002
    003 public class Listing0409
    004 {
    005   public static void main(String[] args)
    006   {
    007     int[][] a = new int[2][3];
    008
    009     a[0][0] = 1;
    010     a[0][1] = 2;
    011     a[0][2] = 3;
    012     a[1][0] = 4;
    013     a[1][1] = 5;
    014     a[1][2] = 6;
    015     System.out.println(""+a[0][0]+a[0][1]+a[0][2]);
    016     System.out.println(""+a[1][0]+a[1][1]+a[1][2]);
    017   }
    018 }
| Listing0409.java

Listing 4.9: Zugriff auf mehrdimensionale Arrays

Die Ausgabe des Programms ist:

    123
    456

|  |  |  | Da mehrdimensionale Arrays als geschachtelte Arrays gespeichert werden, ist es auch möglich, nicht-rechteckige Arrays zu erzeugen. Das folgende Beispiel deklariert und initialisiert ein zweidimensionales dreieckiges Array und gibt es auf dem Bildschirm aus. Gleichzeitig zeigt es die Verwendung der `length`-Variable, um die Größe des Arrays oder Sub-Arrays herauszufinden. |  |
Tip

    001 /* Listing0410.java */
    002
    003 public class Listing0410
    004 {
    005   public static void main(String[] args)
    006   {
    007     int[][] a = { {0},
    008                   {1,2},
    009                   {3,4,5},
    010                   {6,7,8,9}
    011                  };
    012     for (int i=0; i<a.length; ++i) {
    013       for (int j=0; j<a[i].length; ++j) {
    014         System.out.print(a[i][j]);
    015       }
    016       System.out.println();
    017     }
    018   }
    019 }
| Listing0410.java

Listing 4.10: Ein nicht-rechteckiges Array

Die Arbeitsweise des Programms ist trotz der erst in Kapitel 6 vorzustellenden `for`-Schleife unmittelbar verständlich. Die Ausgabe des Programms lautet:

    0
    12
    345
    6789

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de