Kapitel 5: Arrays - Versionsgeschichte

F59Fuchs: /* Deklaration, Erzeugung und Initialisierung eines Arrays */

2014-03-27T17:23:09Z

‎Deklaration, Erzeugung und Initialisierung eines Arrays

F59Fuchs: /* Deklaration, Erzeugung und Initialisierung eines Arrays */

2014-03-27T17:22:47Z

‎Deklaration, Erzeugung und Initialisierung eines Arrays

F59Fuchs: /* Arrays und Schleifen */

2014-03-27T17:21:50Z

‎Arrays und Schleifen

F59Fuchs: /* Arrays und Schleifen */

2014-03-27T17:21:30Z

‎Arrays und Schleifen

B.Schiller am 22. Januar 2014 um 09:23 Uhr

2014-01-22T09:23:08Z

B.Schiller am 20. Januar 2014 um 09:10 Uhr

2014-01-20T09:10:17Z

B.Schiller am 1. November 2013 um 14:03 Uhr

2013-11-01T14:03:10Z

B.Schiller: Die Seite wurde neu angelegt: „Ein '''Array''' oder '''Feld''' ist ein Container, der dazu dient, mehrere Elemente ('''Komponenten''') des gleichen Typs aufzunehmen. Dabei können die Variablen…“

2013-11-01T13:55:49Z

Die Seite wurde neu angelegt: „Ein '''Array''' oder '''Feld''' ist ein Container, der dazu dient, mehrere Elemente ('''Komponenten''') des gleichen Typs aufzunehmen. Dabei können die Variablen…“

Neue Seite

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>

@@ Zeile 21: / Zeile 21: @@
 * das Array mit '''''new''''' dynamisch erzeugen und anschließend die Elemente mit den gewünschten Werten initialisieren:
-<pre>
+<syntaxhighlight lang="java">
 int [] evenNumber;
@@ Zeile 31: / Zeile 32: @@
 evenNumber[3] = 8;
 evenNumber[4] = 10;
-</pre>
+</syntaxhighlight>
@@ Zeile 48: / Zeile 49: @@
 <big>[[Aufgaben 5.1.]]</big>
 ===Arrays und Schleifen===

← Nächstältere Version		Version vom 1. November 2013, 14:03 Uhr
Zeile 1:		Zeile 1:
		+	[[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.		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.

@@ Zeile 38: / Zeile 38: @@
 * das Array über eine '''Initialisierungsliste''' anlegen und gleichzeitig initialisieren:
-<pre>
+<syntaxhighlight lang="java">
 int [] evenNumber = {2,4,6,8,10};
-</pre>
+</syntaxhighlight>
 ::::[[Datei:Array.JPG]]

@@ Zeile 71: / Zeile 71: @@
 '''Hinweis:''' Mit der Methode '''''Arrayname.length''''' kann auf die Länge des Arrays zugegriffen werden.
-<pre>
+<syntaxhighlight lang="java">
 public void mittelwert(){
 //Initialisierung des Arrays
@@ Zeile 82: / Zeile 82: @@
 float mittelwert = summe/zahlen.length;
+}
-</pre>
+</syntaxhighlight>
 <big>[[Aufgaben 5.2.]]</big>

@@ Zeile 58: / Zeile 58: @@
 ''In einem Array sollen alle geraden Zahlen bis 100 abgespeichert werden.''
-<pre>
+<syntaxhighlight lang="java">
 public void geradeZahlen(){
 int [ ] gerade = new int [50];
 for(int i=0; i<gerade.length; i++) { gerade[i] =2+ i*2;}
+}
-</pre>
+</syntaxhighlight>
@@ Zeile 85: / Zeile 85: @@
 <big>[[Aufgaben 5.2.]]</big>
 ===Mehrdimensionale Arrays===

@@ Zeile 183: / Zeile 183: @@
 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;}
+:if(halma[i-1][j-1] == 1 && halma[i-2][j-2] == 0) { halma[i-2][j-2] == 1; 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.

@@ Zeile 26: / Zeile 26: @@
 evenNumber = new int [5];
-int[0] = 2;
+evenNumber[0] = 2;
-int[1] = 4;
+evenNumber[1] = 4;
-int[2] = 6;
+evenNumber[2] = 6;
-int[3] = 8;
+evenNumber[3] = 8;
-int[4] = 10;
+evenNumber[4] = 10;
 </pre>