Akaibel: 1 Version importiert

2026-10-27T17:44:40Z

1 Version importiert

← Nächstältere Version	Version vom 27. Oktober 2026, 17:44 Uhr
(kein Unterschied)

sibiwikialt>Akaibel: /* Beispiel1: Einmal-Eins-Tabelle */

2023-12-06T17:36:49Z

Beispiel1: Einmal-Eins-Tabelle

Neue Seite

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Abitur]]
[[Kategorie:Datenstrukturen(IF)]]
[[Kategorie:Informatik-EF]]

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]''' Link zum Quelltext: '''[https://sibiwiki.de/arrays/ZahlenArray.txt ZahlenArray.txt]''' Link zum Online-Compiler: '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online-compiler]'''

* '''[https://youtu.be/6oktTBAlt88 Video: Arrays, die Objekte enthalten, implementieren]''' ''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=
Hier ist ein Array mit 5 Namen (in Java: <code>String</code>) dargestellt:

{| class="wikitable"
|-
!| 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:'''
{| class="wikitable"
|-
!| 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 <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

|-
|Wert|| "Meier" || "Schmidt" || "Marten" || "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

|-
|Wert|| "Meier" || "Schmidt" || "Müller" || "Franzen" || "Altenburg"
|}
Dieses Array hat 5 Einträge (von Index 0 bis Index 4).

<code>
int anzahl = namen.length;
// 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>// 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;
}</code>
||
 
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 <code>zahlen</code> aufsteigend sortiert ist. 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-1 ; i++){
int aktuelleZahl = zahlen[i];
int nachfolger = zahlen[i+1];
if(nachfolger < aktuelleZahl){
ergebnis = false;
}
}
return ergebnis;
}
</code>
||
 
 
 
 
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 <code>Person</code>
* ein Array für Integer-Zahlen:

<code>
String[] namen;
Person[] personen;
int[] zahlen;
</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'''!.

==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 <code>Person</code>
* ein Array mit 200 Plätzen für Integer-Zahlen:

<code>
namen = new String[5];
personen = new Person[10];
zahlen = new int[200];
</code>
'''Hinweis:''' Hat man die Arrays vorher noch nicht deklariert, muss man das hier nich machen. Dann lauten die Zeilen:
<code>
String[] namen = new String[5];
Person[] personen = new Person[10];
int[] zahlen = new int[200];
</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>. ''
* ''Im Array <code>zahlen</code> 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 <code>namen</code> '''initialisiert''' werden:
{| class="wikitable"
|-
!| Index ||0||1||2||3||4

|-
|Wert|| "Meier" || "Schmidt" || "Müller" || "Franzen" || "Altenburg"
|}

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

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

==Ein Array mit einer <code>for</code>-Schleife initialisieren==
Man kann die Werte eines Arrays auch mit einer [[Schleife (Informatik)#for-Schleife|<code>for</code>-Schleife]] initialisieren.

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

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

==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 <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. 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=
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.

<code>
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;
}
}
</code>

==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>.
* 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:''' '''[https://www.w3schools.com/java/tryjava.asp?filename=demo_compiler w3schools java online compiler]''' Dafür den Quellcode mit Copy&Paste übertragen.

<code>
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");
}
}
</code>

Array - Versionsgeschichte

Akaibel: 1 Version importiert

sibiwikialt>Akaibel: /* Beispiel1: Einmal-Eins-Tabelle */