Arrays (für alle Stufen)

Arrays speichern viele gleiche Variablen

Betrachten wir ein klassisches Beispiel, in dem erklärt wird, was ein Array ist und wie man mit ihm arbeitet.

import java.util.Random;

public class Arraydemo1
{
    int[] liste;
    
    public Arraydemo1()
    {
       liste = new int[32];
    }
    
    public void create()
    {
       Random r = new Random();
       
       for (int i = 0; i < liste.length; i++)
          liste[i] = r.nextInt(1000)+1;
    }
    
    public void show()
    {
       for (int i = 0; i < liste.length; i++)   
          System.out.println(liste[i]);
    }
}

Eine Array-Variable ist in der Lage, eine endliche Anzahl von gleichen Variablen zu speichern. In unserem ersten Beispiel speichert die Array-Variable liste 32 int-Zahlen.

Dazu muss man die Array-Variable wie jede andere Variable zunächst deklarieren. Das geschieht durch folgenden Befehl:

int[] liste;

Hier hat man quasi einen Wunschzettel ausgefüllt: Ich hätte gern eine Array-Variable namens "liste", die in der Lage ist, Daten vom Typ int zu speichern. Es wurde allerdings noch nicht festgelegt, wie viele dieser int-Variablen in dem Array gespeichert werden sollen. Das kommt jetzt:

liste = new int[32];

Mit dieser Befehlszeile wird der Array initialisiert. Jetzt weiß das Programm, dass es im Arbeitsspeicher 32 Speicherzellen reservieren soll, in denen int-Zahlen gespeichert werden können.

Leider enthält dieser Array noch keine Werte, sondern in jeder der 32 Speicherzellen steht die Zahl 0. Das Ziel ist es jetzt, jede dieser Speicherzellen mit einer zufälligen int-Zahl zu belegen. Dazu muss man ein Objekt der Klasse Random erzeugen. Dies geschieht mit der Zeile

Random r = new Random();

Das Objekt der Klasse Random heißt jetzt einfach r.

Die Klasse Random stellt ihren Objekten zahlreiche Methoden zur Verfügung, wie das bei Klassen halt so ist. Eine dieser Methoden heißt nextInt() und liefert eine Zufallszahl in dem angegebenen Bereich. Mit

liste[i] = r.nextInt(1000)+1;

wird der Array-Speicherzelle mit dem Index i ein zufällig gewählter int-Wert zwischen 1 und 1000 zugewiesen. Das ist der Vorteil eines Arrays. Man kann jede einzelne Speicherzelle direkt ansprechen. Dazu muss man nur den Index dieser Zelle kennen. Die erste Speicherzelle eines Array hat immer den Index 0. Daran muss man denken, wenn man mit Arrays arbeitet. Die erste Zelle hat nicht den Index 1, sondern den Index 0.

Bei einem Array, der nur drei oder vier Speicherzellen hat, kann man jede Speicherzelle direkt mit einer Zahl belegen. Das würde dann so aussehen:

liste[0] = r.nextInt(1000)+1;
liste[1] = r.nextInt(1000)+1;
liste[2] = r.nextInt(1000)+1;
liste[3] = r.nextInt(1000)+1;

Bei 32 Zahlen oder mehr nutzt man aber for-Schleifen, um dies zu erledigen:

for (int i = 0; i < liste.length; i++)
   liste[i] = r.nextInt(1000)+1;

Jeder Array hat ein Attribut namens length. Dieses Attribut liefert die Zahl der Speicherzellen zurück, die ein Array belegt. In unserem Beispiel also die Zahl 32. Wichtig ist hier, dass man nicht <= liste.length schreibt, sondern wirklich < liste.length. Würde man <= liste.length schreiben, würde das Programm versuchen, auf das Array-Element mit dem Index 32 zuzugreifen. Dieses Array-Element existiert aber nicht. Das letzte Array-Element hat den Index 31, da ja das erste Element immer den Index 0 hat.

Auch die show()-Methode nutzt jetzt eine for-Schleife, um alle Array-Elemente anzuzeigen. In Fachbüchern der Informatik findet man zwar auch kürzere Methoden, aber im Schul-Unterricht setzen wir die bewährte Methode mit der for-Schleife ein.

Für Fortgeschrittene:

Direkte Initialisierung eines Arrays

Betrachten Sie nun folgendes Beispiel:

public class Arraydemo2
{
   int[] liste = {1,2,3,5,7,11,13,17,19,23,29,31,37,43,47,51};

   public void show()
   {
      for (int i = 0; i < liste.length; i++)   
         System.out.println(liste[i]);
   }
}

Hier wird der Array in einer Zeile deklariert, initialisiert und mit Werten befüllt. Die Array-Werte müssen dazu in geschweiften Klammern stehen, und die einzelnen Werte werden durch Kommata getrennt.

Die for-Schleife der show()-Methode erkennt mittels liste.length, wie viele Elemente der Array enthält.

Diese direkte Initialisierung eines Arrays gelingt nicht nur bei int-Arrays, sondern auch bei float-, double-, boolean-, char- und String-Arrays. Bei char- und String-Arrays müssen die einzelnen Werte natürlich in Anführungszeichen stehen:

String[] englisch = {"dog","cat","mouse","pig","donkey"};

Zweidimensionale Arrays initialisieren

Auch ist es auf diese Weise möglich, zweidimensionale Arrays zu initialisieren und mit Werten zu füllen:

String[][] wortpaar = 
{ {"Hund","dog"},{"Katze","cat"},{"Maus","mouse"},
  {"Schwein","pig"},{"Esel","donkey"} };

Bei zweidimensionalen Arrays (siehe Folge 9) besteht jedes Array-Element aus zwei Komponenten. Das ist zum Beispiel praktisch, wenn man Koordinaten oder Brüche in einem Array speichern möchte. In der ersten Komponente eines jeden Array-Elementes steht dann der X-Wert bzw. der Zähler, in der zweiten Komponente der Y-Wert bzw. der Nenner.

In unserem Beispiel steht in der ersten Komponente ein deutsches Wort und in der zweiten Komponente die zugehörige englische Übersetzung. Mit diesen Informationen können Sie in der Folge 11 punkten!