Array: Unterschied zwischen den Versionen

Aus SibiWiki
Zur Navigation springen Zur Suche springen
 
(33 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 5: Zeile 5:


Arrays dienen zur Speicherung von vielen gleichartigen Elementen (z.B. Zahlen) oder Objekten (z.B. vom Typ <code>Person</code>).
Arrays dienen zur Speicherung von vielen gleichartigen Elementen (z.B. Zahlen) oder Objekten (z.B. vom Typ <code>Person</code>).
=Erklärvideos=
* '''[https://youtu.be/FlScrgcu_Bs Video: Durchlauf durch ein Array Schritt für Schritt erklärt]'''
* '''[https://youtu.be/-MisvNOZAAE Video: Arrays in Java: Einstieg]'''<br/>Link zum Quelltext: '''[http://sibiwiki.de/arrays/ZahlenArray.txt ZahlenArray.txt]'''<br/>Link zum Online-Compiler: '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online-compiler]'''
* '''[https://youtu.be/6oktTBAlt88 Video: Arrays, die Objekte enthalten, implementieren]'''<br/>''Das ist komplizierter als Arrays, die einfach nur Zahlen enthalten...''
* '''[https://youtu.be/URZPClVwh3E Video: Methoden für zweidimensionale Arrays implementieren]'''
=Fachbegriffe=
Index, Wert, Länge, durchlaufen


=Veranschaulichung=
=Veranschaulichung=
Zeile 26: Zeile 38:




=Arrays in Java=
=Arrays in Java - Erklärungen im Detail=
 
==Einzelne Elemente in einem Array ansprechen==
'''Beispiel:'''
{| class="wikitable"
|-
!| Index ||0||1||2||3||4
 
|-
|<b>Wert</b>|| "Meier" || "Schmidt" || "Müller" || "Franzen" || "Altenburg"
|}
 
Der folgende Code...
* liest den Wert bei Index 3 in die Variable <code>derName</code> aus,
* trägt am Index 2 den Wert "Martin" ein.
 
<code>
  String derName = namen[3];
  // derName enthaelt jetzt den Wert "Franzen"
  namen[2] = "Marten";
</code>
 
D.h. das Array sieht jetzt so aus:
{| class="wikitable"
|-
!| Index ||0||1||2||3||4
 
|-
|<b>Wert</b>|| "Meier" || "Schmidt" || <b>"Marten"</b> || "Franzen" || "Altenburg"
|}
 
==Die Länge eines Arrays herausfinden==
Mit dem Schlüsselwort <code>length</code> kann man herausfinden, wie viele Einträge ein Array hat.
 
'''Beispiel:''' Das Array <code>namen</code> soll folgenden Inhalt haben:
{| class="wikitable"
|-
!| Index ||0||1||2||3||4
 
|-
|<b>Wert</b>|| "Meier" || "Schmidt" || "Müller" || "Franzen" || "Altenburg"
|}
Dieses Array hat 5 Einträge (von Index 0 bis Index 4).
 
<code>
  int anzahl = namen.<b>length</b>;
  // anzahl hat jetzt den Wert 5.
</code>
* Für Fortgeschrittene: Jedes Array-Objekt hat ein Attribut <code>length</code>, auf dessen Wert man mit der Punktschreibweise zugreift (im Beispiel also <code>namen.length</code>).
 
==Ein Array mit einer <code>for</code>-Schleife durchlaufen==
Um ein Array von Anfang bis Ende zu durchlaufen, nimmt man eine [[Schleife (Informatik)#for-Schleife|<code>for</code>-Schleife]].
 
'''Beispiel 1:'''
 
Die folgende Methode überprüft, ob die Zahl <code>pZahl</code> im Array <code>zahlen</code> enthalten ist.
 
{| class="wikitable"
! style=min-width:30em | Java !!  style=min-width:30em |Erläuterung
|-
|
<code><i>// Index:        0  1  2  3  4</i>
int[] zahlen = {-3, 7, 7, 2, 2};
public boolean istEnthalten(int pZahl)
{
  boolean ergebnis = false;
  <u>for(int i=0; i<zahlen.length; i++){</u>
    int aktuelleZahl = zahlen[i];
    if(aktuelleZahl == pZahl){
      ergebnis = true;
    }
  }
  return ergebnis;
}</code>
||
&nbsp;
Das Array '''zahlen''' wird deklariert und initialisiert.
'''zahlen''' hat die Länge 5.
&nbsp;
&nbsp;
&nbsp;
<u>Durchlaufe mit einer '''for'''-Schleife alle Indizes von '''zahlen'''</u>
In '''aktuelleZahl''' wird der <u>Wert</u> von '''zahlen''' <u>am Index '''i'''</u> gespeichert.
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
|}
 
 
'''Beispiel 2:'''
 
Die folgende Methode findet heraus, ob das Array <code>zahlen</code> aufsteigend sortiert ist.<br/>Dafür überprüft die Methode, ob es irgendwo den Fall gibt, dass der <code>nachfolger</code> kleiner ist als die <code>aktuelleZahl</code>.
 
{| class="wikitable"
! style=min-width:30em | Java !!  style=min-width:30em |Erläuterung
|-
|
<code>
public boolean istAufsteigendSortiert()
{
  boolean ergebnis = true;
  for(int i=0; i<zahlen.length<u>-1</u> ; i++){
    int aktuelleZahl = zahlen[i];
    int <u>nachfolger</u> = zahlen[i<u>+1</u>];
    if(nachfolger < aktuelleZahl){
      ergebnis = false;
    }
  }
  return ergebnis;
}
</code>
||
&nbsp;
&nbsp;
&nbsp;
&nbsp;
Durchlaufe mit einer for-Schleife alle Indizes von '''zahlen''' - <u>außer dem letzten!</u>
In <u>'''aktuelleZahl'''</u> wird der <u>Wert</u> von '''zahlen''' <u>am Index '''i'''</u> gespeichert.
In <u>'''nachfolger'''</u> wird der <u>Wert</u> von '''zahlen''' <u>am Index '''i+1'''</u> gespeichert.
Jetzt wird verglichen: Wenn '''nachfolger''' kleiner ist als '''aktuelleZahl'''
  Dann hat man einen Fehler in der Sortierung gefunden!
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
|}


== Ein Array deklarieren==
== Ein Array deklarieren==
Zeile 34: Zeile 178:
* ein Array für Integer-Zahlen:
* ein Array für Integer-Zahlen:


<code>
<code>
   String[] namen;
   String[] namen;
   Person[] personen;
   Person[] personen;
   int[] zahlen;
   int[] zahlen;
</code>
</code>


''Damit ist noch nicht die Länge des Arrays festgelegt und es ist noch nichts eingetragen! Das Array hat so den Wert <code>null</code>'', es ist '''noch nicht erzeugt'''!.
''Damit ist noch nicht die Länge des Arrays festgelegt und es ist noch nichts eingetragen! Das Array hat so den Wert <code>null</code>'', es ist '''noch nicht erzeugt'''!.
Zeile 48: Zeile 192:
* ein Array mit 200 Plätzen für Integer-Zahlen:
* ein Array mit 200 Plätzen für Integer-Zahlen:


<code>
<code>
   namen = new String[5];
   namen = new String[5];
   personen = new Person[10];
   personen = new Person[10];
   zahlen = new int[200];
   zahlen = new int[200];
</code>
</code>
'''Hinweis:''' Hat man die Arrays vorher noch nicht deklariert, muss man das hier nich machen. Dann lauten die Zeilen:
'''Hinweis:''' Hat man die Arrays vorher noch nicht deklariert, muss man das hier nich machen. Dann lauten die Zeilen:
<code>
<code>
   String[] namen = new String[5];
   String[] namen = new String[5];
   Person[] personen = new Person[10];
   Person[] personen = new Person[10];
   int[] zahlen = new int[200];
   int[] zahlen = new int[200];
</code>
</code>


* ''In den Arrays <code>namen</code> und <code>personen</code> sind damit 5 (bzw. 10) '''leere''' Plätze entstanden - dort steht als Wert jeweils <code>null</code>. ''
* ''In den Arrays <code>namen</code> und <code>personen</code> sind damit 5 (bzw. 10) '''leere''' Plätze entstanden - dort steht als Wert jeweils <code>null</code>. ''
Zeile 77: Zeile 221:




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


* Hier wurde das Array also in einem Schritt '''deklariert''', '''erzeugt''' und mit Werten '''initialisiert'''.
* Hier wurde das Array also in einem Schritt '''deklariert''', '''erzeugt''' und mit Werten '''initialisiert'''.
==Die Länge eines Arrays herausfinden==
Mit dem Schlüsselwort <code>length</code> kann man herausfinden, wie viele Einträge ein Array hat.
'''Beispiel:''' Das Array <code>namen</code> soll folgenden Inhalt haben:
{| class="wikitable"
|-
!| Index ||0||1||2||3||4
|-
|<b>Wert</b>|| "Meier" || "Schmidt" || "Müller" || "Franzen" || "Altenburg"
|}
Dieses Array hat 5 Einträge (von Index 0 bis Index 4).
<code>
  int anzahl = namen.<b>length</b>;
  // anzahl hat jetzt den Wert 5.
</code>
* Für Fortgeschrittene: Jedes Array-Objekt hat ein Attribut <code>length</code>, auf dessen Wert man mit der Punktschreibweise zugreift (im Beispiel also <code>namen.length</code>).
==Einzelne Elemente in einem Array ansprechen==
'''Beispiel:'''
{| class="wikitable"
|-
!| Index ||0||1||2||3||4
|-
|<b>Wert</b>|| "Meier" || "Schmidt" || "Müller" || "Franzen" || "Altenburg"
|}
Der folgende Code...
* liest den Wert bei Index 3 in die Variable <code>derName</code> aus,
* trägt am Index 2 den Wert "Martin" ein.
<code>
  String derName = namen[3];
  // derName enthaelt jetzt den Wert "Franzen"
  namen[2] = "Martin";
</code>
D.h. das Array sieht jetzt so aus:
{| class="wikitable"
|-
!| Index ||0||1||2||3||4
|-
|<b>Wert</b>|| "Meier" || "Schmidt" || <b>"Marten"</b> || "Franzen" || "Altenburg"
|}
==Ein Array mit einer <code>for</code>-Schleife durchlaufen==
Um ein Array von Anfang bis Ende zu durchlaufen, nimmt man eine [[Schleife (Informatik)#for-Schleife|<code>for</code>-Schleife]].
Beispiel: Der folgende Code gibt alle Werte des Array <code>namen</code> an die Konsole aus.
<code>
  String[] namen = {"Meier", "Schmidt", "Müller", "Franzen", "Altenburg"};
  for(int i=0; i<namen.length; i++){
      System.out.println(namen[i]);
  }
</code>


==Ein Array mit einer <code>for</code>-Schleife initialisieren==
==Ein Array mit einer <code>for</code>-Schleife initialisieren==
Zeile 149: Zeile 233:
Der folgende Code initalisiert die Werte des Arrays <code>dreierReihe</code> mit den Zahlen 0, 3, 6, 9, ..., 3000
Der folgende Code initalisiert die Werte des Arrays <code>dreierReihe</code> mit den Zahlen 0, 3, 6, 9, ..., 3000


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


==Ein Array sortieren==
==Ein Array sortieren==
Dafür bietet sich als einfachstes Verfahren '''[[Bubblesort]]''' an.
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 <code>Leuchtstab</code> und <code>Lampe</code> gilt das folgende Implementationsdiagramm.
[[Datei:Implementationsdiagramm-leuchtstab.jpg|400px|Implementationsdiagramm Leuchtstab und Lampe]]
Im folgenden wird davon ausgegangen, dass die Klasse <code>Lampe</code> 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.<br/>Der fertige und ausführlich dokumentierte Java-Quellcode findet sich unten.''
'''[https://youtu.be/6oktTBAlt88 Video: Arrays, die Objekte enthalten, implementieren]'''
==Java Quellcode der Klasse <code>Leuchtstab</code> mit Erläuterungen==
</code>
'''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;
    }
}
</code>


=Zweidimensionale Arrays=
=Zweidimensionale Arrays=
Zeile 166: Zeile 353:
* deklariert,
* deklariert,
* erzeugt,
* erzeugt,
* mit einer doppelten Schleife durchläuft,
* mit einer '''doppelten''' Schleife durchläuft,
* einzelne Felder ausliest.
* einzelne Felder ausliest bzw. verändert.


<code>
<code>
   public class EinmalEins {
   public class EinmalEins {
     // ein zweidimensionales Array deklarieren
     // ein zweidimensionales Array deklarieren
Zeile 194: Zeile 381:
     }
     }
  }
  }
</code>
</code>


==Beispiel2: Entfernungstabelle==
==Beispiel2: Entfernungstabelle==
* Die folgende Klasse <code>Entfernungstabelle</code> stellt die Verbindung her zwischen dem eindimensionalen Array <code>alleStaedte</code> und dem zweidimensionalen Array <code>alleEntfernungen</code>.
* Die folgende Klasse <code>Entfernungstabelle</code> stellt die Verbindung her zwischen dem eindimensionalen Array <code>alleStaedte</code> und dem zweidimensionalen Array <code>alleEntfernungen</code>.
* Anders als in Beispiel 1 werden hier beide Arrays direkt bei der Deklaration mit Werten belegt.
* Anders als in Beispiel 1 werden hier beide Arrays direkt bei der Deklaration mit Werten belegt.
* ''' Man kann die Klasse direkt in einem Online-Compiler testen, z.B. bei w3schools:''' <br/>'''[https://www.w3schools.com/java/tryjava.asp?filename=demo_compiler w3schools java online compiler]'''<br/>Dafür den Quellcode mit Copy&Paste übertragen.


<code>
<code>
   public class Entfernungstabelle {
   class Entfernungstabelle {
   
   
     private String[] alleStaedte =
     private String[] alleStaedte =
Zeile 216: Zeile 404:
     // wird direkt mit Werten belegt!
     // wird direkt mit Werten belegt!
   
   
     private int[][] alleEntfernungen =
     private '''int[][] alleEntfernungen''' =
     {
     {
       //  B, DO, DD, ER,  F,HAL,  H, KA,  K,  L, MD
       //  B, DO, DD, ER,  F,HAL,  H, KA,  K,  L, MD
Zeile 231: Zeile 419:
         {153,359,244,274,507,176,146,312,456,134,  0}  // MD
         {153,359,244,274,507,176,146,312,456,134,  0}  // MD
     };
     };
      
 
     public int groessteEntfernung() {
        int ergebnis = 0;
        '''for (int zeile = 0; zeile < alleEntfernungen.length; zeile++) {'''
            '''for (int spalte = 0; spalte < alleEntfernungen[zeile].length; spalte++) {'''
                int strecke = '''alleEntfernungen[zeile][spalte]''';
                if(strecke > ergebnis) {
                    ergebnis = strecke;
                }
            }
        }
        return ergebnis; 
    }
     
     public void tabelleAusgeben(){
     public void tabelleAusgeben(){
         // alle Zeilen durchlaufen
         // alle Zeilen durchlaufen
         for (int i = 0; i < alleEntfernungen.length; i++) {
         '''for (int zeile = 0; zeile < alleEntfernungen.length; zeile++)''' {
             System.out.print(alleStaedte[i]+": ");
             System.out.print(alleStaedte[zeile]+": ");
             // in der Zeile die einzelnen Felder durchlaufen
             // in der Zeile die einzelnen Felder durchlaufen
             for (int j = 0; j < alleEntfernungen.length; j++) {
             '''for (int spalte = 0; spalte < alleEntfernungen[zeile].length; spalte++)''' {
                 System.out.print(alleEntfernungen[i][j]+", ");
                 System.out.print('''alleEntfernungen[zeile][spalte]'''+", ");
             }
             }
             System.out.println();
             System.out.println();
Zeile 258: Zeile 459:
         int index1 = this.findeStadtIndex(pStadt1);
         int index1 = this.findeStadtIndex(pStadt1);
         int index2 = this.findeStadtIndex(pStadt2);
         int index2 = this.findeStadtIndex(pStadt2);
         int ergebnis = this.alleEntfernungen[index1][index2];
         int ergebnis = '''alleEntfernungen[index1][index2]''';
         return ergebnis;
         return ergebnis;
     }
     }
Zeile 266: Zeile 467:
         Entfernungstabelle et = new Entfernungstabelle();
         Entfernungstabelle et = new Entfernungstabelle();
         et.tabelleAusgeben();
         et.tabelleAusgeben();
        System.out.println();
        System.out.println("groesste Entfernung:");
        int maxEntfernung = et.groessteEntfernung();
        System.out.println(maxEntfernung);
        System.out.println();
         int entfernung = et.entfernungMessen("Erfurt", "Koeln");
         int entfernung = et.entfernungMessen("Erfurt", "Koeln");
         System.out.println("Von Erfurt nach Koeln sind's: "+entfernung+" km");
         System.out.println("Von Erfurt nach Koeln sind's: "+entfernung+" km");
     }
     }
  }
  }
 
</code>
</code>

Aktuelle Version vom 6. Dezember 2023, 17:36 Uhr


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

Erklärvideos

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. Implementationsdiagramm Leuchtstab und Lampe

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 bzw. verändert.

 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.
  • Man kann die Klasse direkt in einem Online-Compiler testen, z.B. bei w3schools:
    w3schools java online compiler
    Dafür den Quellcode mit Copy&Paste übertragen.

 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 int groessteEntfernung() {
       int ergebnis = 0;
       for (int zeile = 0; zeile < alleEntfernungen.length; zeile++) {
           for (int spalte = 0; spalte < alleEntfernungen[zeile].length; spalte++) {
               int strecke = alleEntfernungen[zeile][spalte];
               if(strecke > ergebnis) {
                   ergebnis = strecke;
               }
           }
       }
       return ergebnis;  
   }
      
   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[zeile].length; spalte++) {
               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 = alleEntfernungen[index1][index2];
       return ergebnis;
   }

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