Home > Informatik > Stufe EF > Lernbausteine

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!

Für Experten:
Spezielle for-Schleife für einfache Arrays

Normalerweise verwendet man eine for-Schleife, wenn man einen Array komplett durchlaufen will. Das ist häufig der Fall, wenn man beispielsweise alle Array-Elemente in der Konsole ausgeben will oder wenn man die Summe oder den Durchschnittswert von Elementen berechnen will. Auch beim Suchen und Sortieren wird oft der gesamte Array durchlaufen.

Angenommen, ein eindimensionaler Array aus int-Zahlen heißt liste und ist so initialisiert worden:

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

Das übliche Vorgehen zum Ausgeben dieser Liste sieht so aus:

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

Hier kann man leicht Fehler machen. Man könnte zum Beispiel aus Versehen mit dem Startwert 1 für die Laufvariable anfangen und dabei das erste Array-Element auslassen, das ja den Index 0 hat. Oder man könnte statt i < liste.lenght schreiben i <= liste.length. Damit würde man ein Array-Element ansprechen, das es überhaupt nicht gibt und so einen Laufzeitfehler hervorrufen.

Seit der Java-Version 5 gibt es aber eine spezielle kurze for-Schleife, mit der man gut einen eindimensionalen Array durchlaufen kann. Hier ein Beispiel:

    public void show()
    {
       for (int element : liste)
          System.out.println(element);       
    }

Die Syntax für diese for-Schleife sieht so aus:

for (Arraytyp lokaleVariable : Arrayname)

In unserem Beispiel ist Arraytyp = int, die lokale Variable heißt element und der Array selbst hat den Namen liste. Die lokale Variable kann nun in der for-Schleife ausgewertet werden. Angenommen, es soll die Summe aller Array-Elemente ermittelt werden, dann geht das mit der kurzen for-Schleife so:

    public int summe()
    {
       int sum = 0;
       
       for (int n : liste)
          sum += n;
          
       return sum;
    }