Array

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

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

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 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:

 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"};

Die Länge eines Arrays bestimmen

Mit dem Schlüsselwort length kann man bestimmen, 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.

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 "Marten" 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"

Ein Array mit einer for-Schleife durchlaufen

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

Beispiel: Der folgende Code gibt alle Werte des Array namen an die Konsole aus.

  String[] namen = {"Meier", "Schmidt", "Müller", "Franzen", "Altenburg"};
  for(int i=0; i<namen.length; i++){
     System.out.println(namen[i]);
  }

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.

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 i = 0; i < alleEntfernungen.length; i++) {
           System.out.print(alleStaedte[i]+": ");
           // in der Zeile die einzelnen Felder durchlaufen
           for (int j = 0; j < alleEntfernungen.length; j++) {
               System.out.print(alleEntfernungen[i][j]+", ");
           }
           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");
   }

}