02.09 Arrays

In den letzten Kapiteln haben Sie viel über Variablen und Schleifen gelernt. Jetzt lernen Sie, wie Sie Variablen sinnvoll mit Schleifen verbinden können. Das Schlagwort hierzu lautet Arrays.

Bis jetzt haben Sie immer jeder Variablen einen Namen gegeben. Mit Arrays ist es möglich mehrere, ähnliche Variablen zu gruppieren. Angenommen Sie schreiben ein Programm für Lottozahlen. Bisher mussten Sie für jede Zahl (Tipp) umständlich eine Variable anlegen.

int tipp1 = 9;
int tipp2 = 13;
int tipp3 = 17;
int tipp4 = 27;
int tipp5 = 32;
int tipp6 = 41;

Ganz zu schweigen vom umständlichen Ausgeben der Werte:

System.out.println(tipp1);
System.out.println(tipp2);
System.out.println(tipp3);
System.out.println(tipp4);
System.out.println(tipp5);
System.out.println(tipp6);

Aber die wahre Arbeit kommt erst noch, wenn Sie die getippten Zahlen mit den gezogenen Ziffern vergleichen wollen …

int gezogen1 = 35;
int gezogen2 = 20;
int gezogen3 = 49;
int gezogen4 = 11;
int gezogen5 = 17;
int gezogen6 = 2;
int richtige = 0;
if (gezogen1 == tipp1) {
  richtige++;
}
else if (gezogen1 == tipp2) {
  richtige++;
}
else if (gezogen1 == tipp3) {
  richtige++;
}
else if (gezogen1 == tipp4) {
  richtige++;
}
else if (gezogen1 == tipp5) {
  richtige++;
}
else if (gezogen1 == tipp6){
  richtige++;
}
if (gezogen2 == tipp1) {
  richtige++;
}
else if (gezogen2 == tipp2) {
  richtige++
}
// usw. usf.

Mithilfe von Arrays und Schleifen können Sie diesen Vorgang erheblich vereinfachen.

Anlegen der Tipps:

int[] tipps = {9, 13, 17, 27, 32, 41};

Ausgabe der Tipps:

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

Vergleich mit den gezogenen Zahlen

int[] gezogen = {35, 20, 49, 11, 17, 2};
int richtige = 0;
for (int i = 0; i < gezogen.length; i++) {
  for (int j = 0; j < tipps.length; j++) {
    if (gezogen[i] == tipps[j]) {
      richtige++;
      break;
    }
  }
}

Deklaration eines Arrays

Ein Array hat immer einen Datentyp. In unserem Fall ist das ein int. Genauso gut könnten wir statt eines ints aber auch ein boolean, double oder eine Klasse als Datentyp verwenden. Nachdem der Datentyp definiert ist, zeigen wir dem Compiler mit einer geöffneten und einer geschlossenen, eckigen Klammer, dass es sich nicht um eine normale Variable, sondern um ein Array handelt. Diese beiden Klammern können auch hinter den Variablennamen geschrieben werden. Anschließend folgt wie gewohnt der Name unseres Arrays mitsamt einem Gleichheitszeichen. Sie können nun wählen, ob Sie Ihrem Array (wie im vorhergehenden Beispiel) sofort Werte zuweisen möchten, oder die Werte später manuell einfügen wollen. Wenn Sie die Werte sofort zuweisen, folgt nach dem Gleichheitszeichen eine geschweifte, offene Klammer, in welche die gewünschten Werte durch Kommata separiert eingetragen werden. Wollen Sie aber die Werte erst später zuweisen, schreiben Sie hinter das Gleichheitszeichen das Schlüsselwort new gefolgt von einem Leerzeichen, der Wiederholung des Datentyps und einem weiteren Eckige-Klammer-Pärchen. In diese Klammern schreiben Sie die Anzahl der Werte, die dieses Array maximal aufnehmen können soll. Abschließend folgt natürlich bei beiden Varianten das übliche Semikolon.

int[] werte1 = {1, 3, 5, 7, 9}; // Sofortige Wertzuweisung
int[] werte2 = new int[5]; // Array mit Max. 5 Werten

Beachten Sie, dass die Elemente eines Arrays, das ohne sofortige Wertzuweisung initialisiert wurde, einen Standardwert zugewiesen bekommen. Dieser ist z. B. bei ints die 0 oder bei Klassen/Objekten null. Siehe hierzu Kapitel 02.03 Primitive Datentypen und Kapitel 04.02 Objekte

Um auf ein bestimmtes Element in einem Array zugreifen zu können, wird dieses einfach über dessen Position angesprochen. Bitte beachten Sie, dass das Element an Position 0 das Erste im Array ist und nicht wie vielleicht angenommen das Element an Position 1.

// Erstes Element im Array ausgeben
System.out.println(werte1[0]);

Jedes Array hat die Konstante length, mit der es möglich ist die Länge des Arrays auszulesen. Dadurch lassen sich auch bequem alle Werte in einem Array ausgeben.

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

Ab Java 1.5 gibt es eine weitere Schleife, die for-each-Schleife. Mit dieser Schleife ist es möglich jedes Element eines Arrays in eine Variable zu speichern und anschließend Auszugeben/weiter zu verarbeiten.

int[] array = {2, 3, 5, 7, 10, 1, 3};
for (int i : array) {
  System.out.println(i);
}

Wenn Sie den Wert eines Elements setzen möchten, so können Sie den dazugehörigen Index wie eine Variable verwenden und den neuen Wert einfach über das Gleichheitszeichen manipulieren.

werte2[0] = 7;
werte2[1] = 19;
werte2[2] = 21;
werte2[3] = 104;
werte2[4] = 11;

Weiterhin besteht die Möglichkeit mehrdimensionale Arrays zu verwenden. Praktisch Arrays in Arrays. Um ein zwei-, drei-, … Dimensionales Array zu erstellen, werden einfach die gewünschte Anzahl an Dimensionen in Form von eckigen Klammern gesetzt. Auch hier gibt es mehrere Initialisierungsmöglichkeiten:

// leeres 2D-Array mit den gewünschten Dimensionen
int[][] array2D1 = new int[4][3];
// volles 2D-Array mit den gewünschten Inhalt
// Die geschweiften Klammern in den geschweiften Klammern
// definieren ein inneres Array
int[][] array2D2 = {{5, 10, 28, 3},{11, 4, 9, 8},{7, 6, 2, 0},{4,5}};
// 2D-Array mit der vorgegebenen Anzahl an inneren Arrays
int[][] array2D3 = new int[5][];
// verschieden große innere Arrays für array2D3 anlegen
array2D3[0] = new int[1];
array2D3[1] = new int[5];
array2D3[2] = new int[3];
array2D3[3] = new int[30];
array2D3[4] = new int[11];

Die Wertzuweisung sieht dann wie folgt aus:

array2D1[0][0] = 1;
array2D1[0][1] = 2;
array2D1[0][2] = 3;
array2D1[1][0] = 4;
array2D1[1][1] = 5;
array2D1[1][2] = 6;
array2D1[2][0] = 7;
// ...

Die Ausgabe eines mehrdimensionalen Arrays erfolgt über verschachtelte Schleifen. In nachfolgenden Beispiel werden Sie zuerst ein 2D-Array mit Werten befüllen und anschließend diese Werte in Form einer Tabelle ausgeben.

int[][] ar2D = {{1, 2, 3, 4, 5},
  {6, 7, 8},
  {9, 10, 11, 12},
  {},
  {13, 14}};
for (int i = 0; i < ar2D.length; i++) {
  for (int j = 0; j < ar2D[i].length; j++) {
    System.out.print(ar2D[i][j] + " ");
  }
  System.out.println();
}

Beachten Sie, dass die Dimensionen eines Arrays auf 255 beschränkt sind.

2 Replies to “02.09 Arrays”

  1. Astropoly

    Bisher hab ich mir ein zweidimensonales Array immer als eine Art Tabelle, ein dreidimensionales als einen Stapel von Tabellen… vorgestellt. Dabei hat jede Tabelle die gleiche (vorher festzulegende) Anzahl von Zeilen und Spalten… Hier scheint es so zu sein, dass jede „Zeile“ unterschiedlich viele Elemente haben kann. Hab ich das richtig verstanden? Liegt das daran, dass ein Array in Java ein Objekt ist und ein zweidimensionales Array im Prinzip ein Array ist, dessen Elemente wieder Arrays, allerdings möglicherweise unterschiedlicher Länge sind? Sind dann auch unterschiedliche Inhaltstypen möglich?
    Gruß Frank

  2. Stefan Kiesel

    Hi Astropoly,

    Ihre Vorstellungen sind soweit auch korrekt. In der Regel werden Sie auf Arrays mit gleicher Anzahl an Spalten und Zeilen treffen. Dennoch ist es prinzipiell in Java möglich (wie Sie am obigen Beispiel sehen können), dass ein mehrdimensionales Array nicht über eine identische Anzahl von Spalten bzw. Zeilen verfügt.

    Genau, Sie können sich ein mehrdimensionales Array wie ein Array in einem anderen Array vorstellen.

    Java ist Typsicher. Deshalb ist es prinzipiell nicht möglich unterschiedliche Typen in einem einzigen Array unterzubringen. Ausnahmen hiervon bilden jedoch Vererbungshierarchien und Schnittstellenimplementierungen. Über diese lernen Sie aber in späteren Kapiteln mehr.

    Gruß
    Stefan

Schreibe einen Kommentar

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.