Array

Arrays dienen zur Speicherung von vielen gleichartigen Elementen (z.B. Zahlen) oder Objekten (z.B. vom Typ Person).

Erklärvideos

• Video: Arrays in Java: Einstieg
  Link zum Quelltext: ZahlenArray.txt
  Link zum Online-Compiler: jdoodle online-compiler

• Video: Arrays, die Objekte enthalten, implementieren
  Das ist komplizierter als Arrays, die einfach nur Zahlen enthalten...

• Video: Methoden für zweidimensionale Arrays implementieren

Fachbegriffe

Index, Wert, Länge, durchlaufen

Veranschaulichung

Hier ist ein Array mit 5 Namen (in Java: String) dargestellt:

Index	0	1	2	3	4
Wert	"Meier"	"Schmidt"	"Müller"	"Franzen"	"Altenburg"

Zu beachten ist:

• Arrays fangen grundsätzlich mit dem Index 0 an.
• Der letzte Index ist deswegen eins niedriger als die Länge des Arrays.

Vorteile und Nachteile

• Vorteil: In einem Array kann man jedes einzelne Element über eine Nummer, den sog. Index, direkt ansprechen.
• Nachteil: Man muss direkt zu Anfang die Größe des Arrays festlegen. D.h. man kann nicht nachträglich beliebig viele Elemente hinzufügen.

Arrays in Java - Erklärungen im Detail

Einzelne Elemente in einem Array ansprechen

Beispiel:

Index	0	1	2	3	4
Wert	"Meier"	"Schmidt"	"Müller"	"Franzen"	"Altenburg"

Der folgende Code...

• liest den Wert bei Index 3 in die Variable derName aus,
• trägt am Index 2 den Wert "Martin" ein.

 String derName = namen[3];
 // derName enthaelt jetzt den Wert "Franzen"
 namen[2] = "Marten";

D.h. das Array sieht jetzt so aus:

Index	0	1	2	3	4
Wert	"Meier"	"Schmidt"	"Marten"	"Franzen"	"Altenburg"

Die Länge eines Arrays herausfinden

Mit dem Schlüsselwort length kann man herausfinden, wie viele Einträge ein Array hat.

Beispiel: Das Array namen soll folgenden Inhalt haben:

Index	0	1	2	3	4
Wert	"Meier"	"Schmidt"	"Müller"	"Franzen"	"Altenburg"

Dieses Array hat 5 Einträge (von Index 0 bis Index 4).

  int anzahl = namen.length;
  // anzahl hat jetzt den Wert 5.

• Für Fortgeschrittene: Jedes Array-Objekt hat ein Attribut length, auf dessen Wert man mit der Punktschreibweise zugreift (im Beispiel also namen.length).

Ein Array mit einer for-Schleife durchlaufen

Um ein Array von Anfang bis Ende zu durchlaufen, nimmt man eine for-Schleife.

Beispiel 1:

Die folgende Methode überprüft, ob die Zahl pZahl im Array zahlen enthalten ist.

Java	Erläuterung
// Index: 0 1 2 3 4 int[] zahlen = {-3, 7, 7, 2, 2}; public boolean istEnthalten(int pZahl) { boolean ergebnis = false; for(int i=0; i<zahlen.length; i++){ int aktuelleZahl = zahlen[i]; if(aktuelleZahl == pZahl){ ergebnis = true; } } return ergebnis; }	Das Array zahlen wird deklariert und initialisiert. zahlen hat die Länge 5.       Durchlaufe mit einer for-Schleife alle Indizes von zahlen In aktuelleZahl wird der Wert von zahlen am Index i gespeichert.

Beispiel 2:

Die folgende Methode findet heraus, ob das Array zahlen aufsteigend sortiert ist.
Dafür überprüft die Methode, ob es irgendwo den Fall gibt, dass der nachfolger kleiner ist als die aktuelleZahl.

Java	Erläuterung
public boolean istAufsteigendSortiert() { boolean ergebnis = true; for(int i=0; i<zahlen.length-1 ; i++){ int aktuelleZahl = zahlen[i]; int nachfolger = zahlen[i+1]; if(nachfolger < aktuelleZahl){ ergebnis = false; } } return ergebnis; }	Durchlaufe mit einer for-Schleife alle Indizes von zahlen - außer dem letzten! In aktuelleZahl wird der Wert von zahlen am Index i gespeichert. In nachfolger wird der Wert von zahlen am Index i+1 gespeichert. Jetzt wird verglichen: Wenn nachfolger kleiner ist als aktuelleZahl Dann hat man einen Fehler in der Sortierung gefunden!

Ein Array deklarieren

Beispiel: Hier werden deklariert:

• ein Array für Strings,
• ein Array für Objekte vom Typ Person
• ein Array für Integer-Zahlen:

 String[] namen;
 Person[] personen;
 int[] zahlen;

Damit ist noch nicht die Länge des Arrays festgelegt und es ist noch nichts eingetragen! Das Array hat so den Wert null, es ist noch nicht erzeugt!.

Ein Array als leeres Array erzeugen

Beispiel: Hier werden die Arrays jeweils als leeres Array erzeugt:

• Ein Array mit 5 Plätzen für Strings,
• ein Array mit 10 Plätzen für Objekte vom Typ Person
• ein Array mit 200 Plätzen für Integer-Zahlen:

 namen = new String[5];
 personen = new Person[10];
 zahlen = new int[200];

Hinweis: Hat man die Arrays vorher noch nicht deklariert, muss man das hier nich machen. Dann lauten die Zeilen:

 String[] namen = new String[5];
 Person[] personen = new Person[10];
 int[] zahlen = new int[200];

• In den Arrays namen und personen sind damit 5 (bzw. 10) leere Plätze entstanden - dort steht als Wert jeweils null.
• Im Array zahlen dagegen ist 200mal die Zahl 0 eingetragen.
• Die Arrays sind also erzeugt und mit den Standardwerten null bzw. 0 initialisiert worden.

Ein Array mit vorgegebenen Werten initalisieren

Oft weiß man schon bei der Deklaration eines Arrays, welche Werte es haben soll. Das lässt sich in Java wie folgt realisieren.

Beispiel: Die folgende Tabelle soll als Array namen initialisiert werden:

Index	0	1	2	3	4
Wert	"Meier"	"Schmidt"	"Müller"	"Franzen"	"Altenburg"

  String[] namen = {"Meier", "Schmidt", "Müller", "Franzen", "Altenburg"};

• Hier wurde das Array also in einem Schritt deklariert, erzeugt und mit Werten initialisiert.

Ein Array mit einer for-Schleife initialisieren

Man kann die Werte eines Arrays auch mit einer for-Schleife initialisieren.

Beispiel: Der folgende Code initalisiert die Werte des Arrays dreierReihe mit den Zahlen 0, 3, 6, 9, ..., 3000

  int[] dreierReihe = new int[1001];
  for(int i = 0; i < dreierReihe.length; i++){
     dreierReihe[i] = i*3;
  }

Ein Array sortieren

Dafür bietet sich als einfachstes Verfahren Bubblesort an.

Arrays, die Objekte enthalten (Beispiel)

Ein Leuchtstab besteht aus 5 Lampen nebeneinander. Man soll jede Lampe einzeln anschalten können. Man soll alle Lampen gleichzeitig anschalten können. Man soll abfragen können, wie viele Lampen an sind.

Für die Klassen Leuchtstab und Lampe gilt das folgende Implementationsdiagramm.

Im folgenden wird davon ausgegangen, dass die Klasse Lampe schon fertig implementiert vorliegt und dass man auf ihre Methoden wie im Implementationsdiagramm vorgesehen zugreifen kann.

Erklärvideo

Im folgenden Erklärvideo geht es darum, wie man die Klasse Leuchtstab implementiert.
Der fertige und ausführlich dokumentierte Java-Quellcode findet sich unten.

Video: Arrays, die Objekte enthalten, implementieren

Java Quellcode der Klasse Leuchtstab mit Erläuterungen

public class Leuchtstab
{
   // das Attribut fuer die Lampen deklarieren - die Laenge ist damit noch nicht festgelegt!
   // das Array ist vom Typ Lampe. 
   // durch [] wird geklaert, dass es sich um ein Array handelt.
   private Lampe[] lampen;
   
   // Konstruktor der Klasse Leuchtstab
   public Leuchtstab()
   {
       // Das Array Lampen mit der Laenge 5 erzeugen.
       lampen = new Lampe[5];
       // Bis jetzt sind nur 5 Plaetze fuer Lampen geschaffen.
       // Jetzt muss auf jeden Platz eine Lampe gesetzt werden.
       // Dafuer wird das Array lampen durchlaufen.' 
       for(int i=0; i<lampen.length; i++)
       {
           // eine Lampe erzeugen und in der lokalen Variable l speichern.
           Lampe l = new Lampe();
           // die Lampe beim Index i in das Array eintragen.
           lampen[i] = l;
           // die Lampe richtig positionieren - abhaengig vom Index i
           // Dafuer wird fuer die Lampe l die Methode horizontalBewegen(...) aufgerufen...
           // ...so wie sie im Implementationsdiagramm steht!
           l.horizontalBewegen(i*50);
       }
   }
   
   // Methode, um eine einzelne Lampe anzuschalten.
   // Die Nummer der Lampe wird als Parameter uebergeben.
   public void anschalten(int pNr)
   {
       // die richtige Lampe aus dem Array lampen auslesen... 
       // ...und in der lokalen Variable l speichern.
       Lampe l = lampen[pNr];
       // Die Lampe l anschalten.
       // Dafuer wird fuer die Lampe l die Methode anschalten() aufgerufen...
       // ...so wie sie im Implementationsdiagramm steht!
       l.anschalten();
   }
   
   public void alleLampenAnschalten()
   {
       // Das Array lampen mit einer for-Schleife durchlaufen.
       for(int i=0; i<lampen.length; i++)
       {
           // die i-te Lampe in der lokalen Variable l (vom Typ Lampe) speichern.
           Lampe l = lampen[i];
           // fuer die Lampe l die Methode anschalten aufrufen.
           l.anschalten();
       }
   }
   
   // Die Methode hat Rueckgabe-Typ int...
   // ... weil sie eine Anzahl berechnet und zurueckgibt.
   public int wievieleSindAn()
   {
       // eine lokale Variable ergebnis deklarieren...
       // ... vom selben Typ wie der Rueckgabetyp der Methode!
       // ergebnis mit 0 initalisieren.
       int ergebnis = 0;
  
       // Das Array lampen mit einer Schleife durchlaufen
       for(int i=0; i<lampen.length; i++)
       {
           // die i-te Lampe in der lokalen Variable l (vom Typ Lampe) speichern.
           Lampe l = lampen[i];
           // Pruefen, ob die Lampe l an ist...
           // ... dafuer ruft man die Methode laut Implementationsdiagramm auf!
           if(l.istAn() == true)
           {
               // Die i-te Lampe ist an, deswegen...
               // ... wird das ergebnis eins hochgezaehlt.
               ergebnis++;
           }
       }  
       // nach dem Ende der for-Schleife...
       // ergebnis zurueckgeben.
       return ergebnis;
   }
}

Zweidimensionale Arrays

In Java kann man auch zwei- (und mehr-) dimensionale Arrays realisieren.

Beispiel1: Einmal-Eins-Tabelle

Am folgenden Beispiel kann man sehen, wie man ein zweidimensionales Array...

• deklariert,
• erzeugt,
• mit einer doppelten Schleife durchläuft,
• einzelne Felder ausliest.

 public class EinmalEins {
   // ein zweidimensionales Array deklarieren
   public int[][] tabelle;
  
   public EinmalEins(){
       // ein zweidimensionales Array der Groesse 10x10 erzeugen.
       tabelle = new int[10][10];
      
       // das Array belegen:
       // die Zeilen des Arrays (von oben nach unten) mit einer Schleife durchlaufen
       for (int i = 0; i < tabelle.length; i++) {
           die i-te Zeile des Arrays mit einer Schleife durchlaufen
           for (int j = 0; j < tabelle[i].length; j++) {
               // Auf das Feld (i|j) das Produkt eintragen
               tabelle[i][j] = i*j;
           }
       }
   }
  
   public int multipliziere(int zahl1, int zahl2){
       int ergebnis = tabelle[zahl1][zahl2];
       return ergebnis;
   }
}

Beispiel2: Entfernungstabelle

• Die folgende Klasse Entfernungstabelle stellt die Verbindung her zwischen dem eindimensionalen Array alleStaedte und dem zweidimensionalen Array alleEntfernungen.
• Anders als in Beispiel 1 werden hier beide Arrays direkt bei der Deklaration mit Werten belegt.

 public class Entfernungstabelle {

   private String[] alleStaedte =
   {
       "Berlin","Dortmund",
       "Dresden","Erfurt",
       "Frankfurt","Halle",
       "Hannover","Kassel",
       "Koeln","Leipzig",
       "Magdeburg"
   };

   // das zweidimensionale Array alleEntfernungen
   // wird direkt mit Werten belegt!

   private int[][] alleEntfernungen =
   {
     //   B, DO, DD, ER,  F,HAL,  H, KA,  K,  L, MD
       {  0,512,297,327,660,229,299,465,609,187,153}, // B
       {512,  0,553,354,226,535,213,163, 97,493,359}, // DO
       {297,553,  0,199,585,152,390,390,650,110,244}, // DD
       {327,354,199,  0,386,182,357,191,451,140,274}, // ER
       {660,226,585,386,  0,568,361,195,187,526,507}, // F
       {229,535,152,182,568,  0,322,373,632, 42,176}, // HAL
       {299,213,390,357,361,322,  0,166,310,280,146}, // H
       {465,163,390,191,195,373,166,  0,260,331,312}, // KA
       {609, 97,650,451,187,632,310,260,  0,591,456}, // K
       {187,493,110,140,526, 42,280,331,591,  0,134}, // L
       {153,359,244,274,507,176,146,312,456,134,  0}  // MD
   };
   
   public void tabelleAusgeben(){
       // alle Zeilen durchlaufen
       for (int zeile = 0; zeile < alleEntfernungen.length; zeile++) {
           System.out.print(alleStaedte[zeile]+": ");
           // in der Zeile die einzelnen Felder durchlaufen
           for (int spalte = 0; spalte < alleEntfernungen[spalte].length; j++) {
               System.out.print(alleEntfernungen[zeile][spalte]+", ");
           }
           System.out.println();
       }
   }

   // sucht zu einer Stadt den richtigen Index in der Entfernungstabelle
   public int findeStadtIndex(String pStadt){
       for (int i = 0; i < alleStaedte.length; i++) {
           if(alleStaedte[i].equals(pStadt)){
               return i;
           }
       }
       // Stadt nicht gefunden!
       return -1;
   }
  
   private int entfernungMessen(String pStadt1, String pStadt2) {
       int index1 = this.findeStadtIndex(pStadt1);
       int index2 = this.findeStadtIndex(pStadt2);
       int ergebnis = this.alleEntfernungen[index1][index2];
       return ergebnis;
   }

   public static void main(String[] args) {
       // die gewuenschte Methode einkommentieren!
       Entfernungstabelle et = new Entfernungstabelle();
       et.tabelleAusgeben();
       int entfernung = et.entfernungMessen("Erfurt", "Koeln");
       System.out.println("Von Erfurt nach Koeln sind's: "+entfernung+" km");
   }

}