Iteratoren (nur erNi und Prüflinge auf gruNi)

Kü / Info Projekt
Einschub III Skript OOP Raumplanung
Sj. 2012/2013
______________________________________
Einschub grundlegende Programmierstrukturen
in Java III
1. Arrays
Arrays einfach – http://youtu.be/pHU9g4ZoVNw
Um mehrere ähnliche Daten zu speichern (z.B. die Objekte, die gesammelt wurden), ist es
häufig sinnvoll mit sogenannten Arrays zu arbeiten, in die die einzelnen Daten hineingepackt
werden.
Ein Array ist ein Feld, in welchem viele Werte vom gleichen Typ gespeichert werden können,
auf die man anschließend aber einzeln und gezielt zugreifen kann.
Bsp:
Ein Array der Größe 10 soll angelegt werden. In den einzelnen Feldern des Arrays sollen
anschließend Buchstaben gespeichert werden.
//in Java sähe das folgendermaßen aus
//ein Buchstaben-Array anlegen
char buchstabenFeld[] = new char [10];
//nun können in jedes Feld gezielt Buchstaben gespeichert werden.
buchstabenFeld[0] = `A‘; //beachte, das Feld beginnt immer beim Index von 0!
buchstabenFeld[1] = `B‘;
…
buchstabenFeld[9] = „K“; // das ist das letzte Element.
//das Feld sähe dann im Speicher folgendermaßen aus:
A
B
C
D
E
F
G
H
I
K
//oder ein Array aus Zahlen (beliebig gewählt hier)
int zahlenFeld[] = new int [10];
zahlenFeld[0] = 5;
zahlenFeld[1] = 4;
zahlenFeld[2] = 12;
zahlenFeld[3] = 8;
zahlenFeld[4] = 1;
zahlenFeld[5] = 0;
zahlenFeld[6] = 9;
zahlenFeld[7] = 8;
zahlenFeld[8] = 13;
zahlenFeld[9] = 5;
//das Feld sähe dann im Speicher folgendermaßen aus:
5
4
12
8
1
0
9
8
13
5
//Man behandelt die einzelnen Felder des Arrays im Prinzip wie gewöhnliche Variablen. Man
//kann also Werte auslesen, oder neue zuweisen.
zahlenFeld[3]++; //würde nun 9 als Wert beinhalten.
zahlenFeld[0] = zahlenFeld[5]+zahlenfeld[6]; //zahlenFeld[0] hat nun den Wert 16
Kü / Info Projekt
Einschub III Skript OOP Raumplanung
Sj. 2012/2013
Man kann aber auch ganze Objekte in je ein Array-Feld hineinpacken. Dazu muss man zu
Beginn nur genügend Speicherplatz reservieren:
Schrank schraenke[] = new Schrank[10];
Und dann z.B.:
schrank[0] = new Schrank(i*schrankbreite, 0,farbe, orientierung,
schrankbreite, tiefe);
2. ArrayList
Array List – http://youtu.be/4_EYHD3rwMc
Der Nachteil bei Arrays ist, dass man zu Beginn schon festlegen muss, für wie viele Objekte
der Speicher geblockt werden soll (in den eckigen Klammern muss eine bestimmte Zahl
stehen z.B. [10]). Wenn aber nur weniger Objekte gebraucht werden, bleibt der Speicher
blockiert, auch wenn er nicht genutzt wird. Werden mehr Objekte gebraucht, so ist das im
Nachhinein nicht möglich, noch ein oder mehrere Elemente anzuhängen.
Weiß man also nicht, wie viele Elemente das Array speichern soll, so muss man mit
sogenannten ArrayLists arbeiten. Das sind dynamische Arrays, bei denen jeweils ein neues
Element erzeugt und hinten angehängt wird, wenn es gebraucht wird. Es handelt sich hier
um verkettete Listen:
Inhalt des Listenelementes
Startadresse
Adresse Nachfolgerelement
a
b
c
d
Listenelement
Nachteil: Die neuen Elemente werden immer hinten an die schon bestehende Kette
angehängt. Der Zugriff ist etwas komplizierter, als bei Arrays.
Man kann Elemente verschiedenen Typs in eine ArrayList hineinpacken. Möchte man nur
einen bestimmten Typ zulassen, so muss das beim Erzeugen der ArrayList speziell angegeben
werden (s.u.)
Im Programmcode sieht das folgendermaßen aus:
//um es zu benutzen, sollte man zu Beginn Folgendes importieren:
import java.util.*;
ArrayList<Schrank> test = new ArrayList<Schrank>();
//um genau zu sein, werden hier schon mal 10 Elemente angelegt,
können aber beliebig erweitert werden
//um ein Element hinzuzufügen (am Ende der ArrayList):
Schrank s1 = new Schrank();
test.add(s1);
//um ein Element hinzuzufügen (an einer bestimmten Position mitten
//in der ArrayList):
//hier an die 3te Position
test.add(2,s1);
Kü / Info Projekt
Einschub III Skript OOP Raumplanung
Sj. 2012/2013
//um ein Element auszugeben, hier, das 0-te Element, und von dem
dessen xPosition (müsste auf public gesetzt sein die
Instanzvariable, damit das geht, ist hier nur ein Beispiel)
System.out.println(“Element: “ + test.get(0).xPosition);
//um ein Element zu ändern, bzw. den Inhalt des Elementes zu ändern,
hier, das i-te Element, und von dem dessen xPosition (müsste auf
public gesetzt sein die Instanzvariable, damit das geht, ist hier
nur ein Beispiel)
//einen neuen Schrank erzeugen, eine Kopie sozusagen, um auf die
//konkreten Instanzvariablen zugreifen zu können und zu ändern,
//dann mit set den ganzen Schrank neu setzen in der ArrayList
Schrank s1 = test.get(i); //den iten Schrank nehmen und bearbeiten
s1.xPosition = 10;
// eine neue Position festlegen
test.set(i, s1);
//um die gesamte Liste zu durchlaufen, kann man eine while oder eine
einfache for-Schleife verwenden.
//man muss allerdings bei dieser Art wissen, wie viele Elemente in
der Liste enthalten sind.
//angenommen anzahl ist die Zahl der enthaltenen Elemente
for(int i=0; i<anzahl; i++){
System.out.println(„Position x: “ + test.get(i).xPosition);
}
Wenn man die Anzahl der Elemente nicht kennt, aber die gesamte Liste durchgehen möchte,
bieten sich sogenannte erweiterte for-Schleifen an (nur erNi):
//um die gesamte Liste zu durchlaufen
//springt man sozusagen von Element zu Element und liefert von
//jedem Element, was nötig ist
//der index kann hier weggelassen werden, da man einfach Element für
Element durchgeht
for (Schrank aktSchrank : test) {
System.out.println(„Position x: “ + aktSchrank.xPosition);
}
//um ein Element zu entfernen
test.remove(i);
Wichtig zu beachten: es wird nur eine Referenz auf das Objekt in der Liste gespeichert, nicht
eine Kopie des Objektes. Wird also etwas vom Zustand des Objektes anschließend verändert,
so ändert sich anschließend auch die Ausgabe der ArrayList-Daten.
Anstatt die Sammlungen (wie z.B. ArrayList) mit einer for- oder while-Schleife und einem
Zähler zu durchlaufen, kann man auch Iteratoren (oder eine erweiterte for-Schleife – s.o.)
verwenden. Vorteil dabei ist es, dass man keine konkrete Grenze angeben muss, bis wohin
durchlaufen werden soll, man läuft einfach komplett durch (eignet sich also nur, wenn die
ganze Sammlung durchlaufen werden soll).
Kü / Info Projekt
Einschub III Skript OOP Raumplanung
Sj. 2012/2013
3. Iteratoren (nur erNi und Prüflinge auf gruNi)
Jede Sammlungsklasse kann auf eine Methode iterator() zugreifen, die es erlaubt die
Elemente der Sammlung über die Methode next() Element für Element zu durchlaufen.
Diese Methode ist ähnlich der erweiterten for-Schleife.
Iterator<Schrank> it = test.iterator();
// solange noch ein Element in der Sammlung enthalten ist
while (it.hasNext()){
System.out.println(„Position x: “ + it.next().xPosition);
}
Aufgabe
1. Lege eine Klasse Test an, die über den Konstruktor eine Anzahl aufnimmt und dann
ein Array erzeugt mit der angegebenen Anzahl von Elementen. Die Elemente sollen
vom Typ String sein und als leere Strings initialisiert werden. In der Klasse soll es eine
Methode aendere(int nummer, String wert) geben, die einen Parameter int nummer
bekommt und einen Parameter String wert übergeben bekommt. Wird die Methode
auf ein Test-Objekt angewendet, so soll das Array-Element mit dem Index nummer
auf den Inhalt wert geändert werden. Des Weiteren soll die Klasse eine Methode
ausgabe( int nummer) haben, welche den Wert des Arrayelementes des Indexes nummer
ausgibt. Die Klasse soll auch eine Methode ausgabe_alle() haben, welche das gesamte
Array (die Inhalte der Elemente) ausgibt.
2. Schreibe die Klasse Test so um, dass sie anstatt mit einem Array, mit einer Array-List
arbeitet.
3. Schreibe die Klasse so um, dass am Ende die Elemente über einen Iterator
ausgegeben werden.
4. Schreibe die Klasse so um, dass am Ende die Elemente über eine erweiterte forSchleife ausgegeben werden.
Es gibt noch eine Menge mehr hierzu zu wissen, es ist eine wirklich interessante Struktur,
sprengt aber leider den Rahmen des Unterrichts. Es gibt auch noch echte Listen in Java, die
sehr interessant sind. Wenn du hierzu mehr wissen möchtest, dann schau doch mal unter:
http://openbook.galileodesign.de/javainsel5/javainsel11_002.htm
(generell ein super Nachschlagewerk)
Was solltest du nun können:
1. Arrays und ArrayLists erzeugen und verwalten können.
2. Sammlungen mit Iteratoren oder erweiterten for-Schleifen durchlaufen können