Quelltext der Seite Kapitel 5: Arrays

[[Informatik_10._Klasse_13-14|Zur Startseite]] - [[Kapitel_1:_Vorbereitende_Aufgaben_und_Einstieg|Kapitel 1]] - [[Kapitel_2:_Variablen_und_Datentypen|Kapitel 2]] - [[Kapitel_3:_Kontrollstrukturen|Kapitel 3]] - [[Kapitel_4:_Methoden|Kapitel 4]]

Ein '''Array''' oder '''Feld''' ist ein Container, der dazu dient, mehrere Elemente ('''Komponenten''') des gleichen Typs aufzunehmen. Dabei können die Variablen über einen gemeinsamen Namen angesprochen werden und unterscheiden sich lediglich durch einen '''Index'''. Man kann sich das Array als eine lange Reihe gleichartiger Schubladen vorstellen, die durchnummeriert sind und deren Nummerierung mit 0 beginnt. Nach der Deklaration und Erzeugung des Arrays steht eine festgelegte Anzahl von Schubladen zur Verfügung, die nicht mehr geändert werden kann. Der festgelegte Datentyp ist sozusagen der Schlüssel um diese Schubladen zu öffnen und einen bestimmten Wert oder eine Referenz auf ein Objekt darin abzulegen. Der Vorteil von Arrays gegenüber einer entsprechenden Anzahl einfacher Variablen ist, dass Arrays sich leicht mit Schleifen bearbeiten lassen, da der Index einer Array-Komponente eine Variable sein kann und als Laufvariable in einer Schleife benutzt werden kann.


===Deklaration, Erzeugung und Initialisierung eines Arrays===

Die Definition einer '''Array-Variablen''' bedeutet in Java nicht das Anlegen eines Arrays, sondern die Definition einer '''Referenzvariablen''', die auf ein '''Array-Objekt''' zeigen kann.

Die allgemeine Form der Definition einer Referenzvariablen zum Zugriff auf ein Array lautet:  


:::::'''Datentyp [ ] Arrayname;'''


'''Beispiele:''' int [ ] fibonacci, double [ ] messwert, String [ ] wort


Zum '''Erzeugen''' des Array-Objekts gibt es zwei Möglichkeiten:

* das Array mit '''''new''''' dynamisch erzeugen und anschließend die Elemente mit den gewünschten Werten initialisieren:

<pre>
int [] evenNumber;

evenNumber = new int [5];

int[0] = 2;
int[1] = 4;
int[2] = 6;
int[3] = 8;
int[4] = 10;
</pre>



* das Array über eine '''Initialisierungsliste''' anlegen und gleichzeitig initialisieren:

<pre>
int [] evenNumber = {2,4,6,8,10};
</pre>

::::[[Datei:Array.JPG]]


'''Beachte:''' Eine Array-Variable ist eine Referenz auf ein Array-Objekt. Mit der Deklaration einer Array-Variable ist aber das Array-Objekt selbst noch nicht angelegt.


<big>[[Aufgaben 5.1.]]</big>


===Arrays und Schleifen===

Felder und Schleifen sind in der Programmierung eng verbunden. Wir verwenden Felder um die Vielzahl von Werten, die beim Durchlauf einer Schleife entstehen, zu speichern. Oder wir benutzen Schleifen um Felder zu initialisieren oder um Werte aus einem Array auszulesen.


'''Beispiel für die Initialisierung:'''

''In einem Array sollen alle geraden Zahlen bis 100 abgespeichert werden.''
<pre>
public void geradeZahlen(){
int [ ] gerade = new int [50];
for(int i=0; i<gerade.length; i++) { gerade[i] =2+ i*2;}
}
</pre>


'''Beispiel für das Auslesen:'''

''Aus einem Array sollen Zahlen ausgelesen werden und ihr Mittelwert errechnet werden.''

'''Hinweis:''' Mit der Methode '''''Arrayname.length''''' kann auf die Länge des Arrays zugegriffen werden.
<pre>
public void mittelwert(){
//Initialisierung des Arrays
int [ ] zahlen = {3, 2, 5, 4, 1, 6};
//Einführung einer Hilfsvariable für die Summe
float summe = 0;
//Berechnung der Summe
for (int i=0; i<zahlen.length; i++){summe = summe+zahlen[ i ];}
//Berechnung des Mittelwerts
float mittelwert = summe/zahlen.length;
}
</pre>

<big>[[Aufgaben 5.2.]]</big>



===Mehrdimensionale Arrays===

Mehrdimensionale Arrays stellen Arrays aus Arrays dar und können beispielsweise zur Darstellung eines Spielfeldes (Schach etc.) verwendet werden. Sie werden wie in folgendem Beispiel erzeugt:

int [ ][ ] halma = new int [8][8];


Das Halma-Spiel verwendet ein Schachbrett als Spielfläche, d.h. ein rechteckiges Feld der Größe 8x8. Die Felder werden mit den Bezeichnungen halma [0][0] bis halma [7][7] referenziert:

{| class="wikitable" border="1" 
|-
| halma [0][0]
| halma [0][1]
| halma [0][2]
| halma [0][3]
| halma [0][4]
| halma [0][5]
| halma [0][6]
| halma [0][7]
|-
| halma [1][0]
| halma [1][1]
| halma [1][2]
| halma [1][3]
| halma [1][4]
| halma [1][5]
| halma [1][6]
| halma [1][7]
|-
| halma [2][0]
| halma [2][1]
| halma [2][2]
| halma [2][3]
| halma [2][4]
| halma [2][5]
| halma [2][6]
| halma [2][7]
|-
| halma [3][0]
| halma [3][1]
| halma [3][2]
| halma [3][3]
| halma [3][4]
| halma [3][5]
| halma [3][6]
| halma [3][7]
|-
| halma [4][0]
| halma [4][1]
| halma [4][2]
| halma [4][3]
| halma [4][4]
| halma [4][5]
| halma [4][6]
| halma [4][7]
|-
| halma [5][0]
| halma [5][1]
| halma [5][2]
| halma [5][3]
| halma [5][4]
| halma [5][5]
| halma [5][6]
| halma [5][7]
|-
| halma [6][0]
| halma [6][1]
| halma [6][2]
| halma [6][3]
| halma [6][4]
| halma [6][5]
| halma [6][6]
| halma [6][7]
|-
| halma [7][0]
| halma [7][1]
| halma [7][2]
| halma [7][3]
| halma [7][4]
| halma [7][5]
| halma [7][6]
| halma [7][7]
|}


Jede Mannschaft verfügt über 8 Spielsteine. Schwarze Steine werden mit "1" gekennzeichnet, weiße mit "2", leere Felder mit "0". Belegungungen würden folgendermaßen aussehen:

:halma [0][0] = 1 (schwarzer Stein)

:halma [7][7] = 2 (weißer Stein)

:halma [6][1] = 0 (leeres Feld)

Eine Spielregel für einen Zug könnte exemplarisch folgendermaßen formuliert werden:

:if(halma[i-1][j-1] == 2 && halma[i-2][j-2] == 0) { halma[i-2][j-2] == 2; halma [i][j] = 0;}

d.h. wenn diagonal vor einem schwarzen Stein ein weiterer schwarzer Stein steht und das dahinterliegende Feld leer ist, darf gezogen werden und die Konstellation der Steine verändert sich.


Auch Arrays höherer Dimension sind möglich und werden entsprechend deklariert (z.B. int [ ] [ ] [ ] wuerfel = new int [3][3][3] um einen Würfel der Größe 3x3x3 darzustellen.)


<big>[[Aufgaben 5.3.]]</big>