 Liste |
Batista
unregistriert
 |
|
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
|
/** Array-basierte Liste fuer Daten vom Typ Object */
public class ObjectArray {
/** Datenspeicher */
Object[] array;
/** Anzahl der belegten Eintraege */
int belegt;
/** Konstruktor fuer eine leere Liste
*
* @param maxsize Maximale Groesse
*/
public ObjectArray(int maxsize) {
array = new Object[maxsize];
belegt = 0;
};
/** Direktzugriff auf ein Element */
public Object get(int position) {
return array[position];
}
/** Laenge der Liste. */
public int size() {
return belegt;
}
/** Element am Ende einfuegen */
public void append(Object daten) {
if (belegt == array.length) {
throw new ArrayIndexOutOfBoundsException("Liste ist voll.");
}
array[belegt] = daten;
belegt += 1;
}
/** Element am Anfang einfuegen */
public void prepend(Object daten) {
if (belegt == array.length) {
throw new ArrayIndexOutOfBoundsException("Liste ist voll.");
}
for(int i = belegt; i > 0; i--) {
array[i] = array[i - 1];
}
array[0] = daten;
belegt += 1;
}
}
|
|
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
|
import java.util.*;
/** Array-basierte Liste fuer Daten vom Typ Object */
public class ObjectArrayPlus extends ObjectArray implements Iterable<Object> {
/** Konstruktor fuer eine leere Liste
*
* @param maxsize Maximale Groesse
*/
public ObjectArrayPlus(int maxsize) {
super(maxsize);
};
/** Element aus Liste entfernen */
public void remove(int idx) {
// TODO: Implementieren
}
/** Einen Iterator fuer die Liste erzeugen */
public Iterator<Object> iterator() {
return new Iter();
}
/** Implementierung eines Iterators */
public class Iter implements Iterator<Object> {
/** Aktuelle Position */
int position;
/** Konstruktur */
public Iter() {
position = 0;
}
/** Zum naechsten Element gehen */
public Object next() {
// TODO: Implementieren
}
/** Test, ob die Liste ein naechstes Element hat */
public boolean hasNext() {
// TODO: Implementieren
}
/** Entfernen nicht erlaubt. */
public void remove() {
throw new UnsupportedOperationException();
}
}
/** Methode zum Testen der Implementierung */
// Hinweis: in der Praxis wuerde man hier einen Unit-Test verwenden!
public static void main(String[] args) {
ObjectArray liste = new ObjectArray(10);
liste.prepend(2);
liste.prepend(1);
liste.append(3);
liste.append(4);
liste.prepend(0);
System.out.println("Ist die Laenge 5? "+liste.size());
System.out.println("Die naechstes Zeile sollte dies sein: '0 1 2 3 4'!");
for (Object i : liste) {
System.out.print(i+" ");
}
System.out.println();
System.out.println("Die naechste Zeile sollte leer sein, aber keinen Fehler verursachen!");
for (Object i : new ObjectArray(10)) {
System.out.print(i+" ");
}
System.out.println();
// TODO: Fuegen Sie einen sinnvollen Test fuer die remove(i) methode hinzu
}
}
|
|
Den Code entsprechend ergänzt
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
|
import java.util.*;
/** Array-basierte Liste fuer Daten vom Typ Object */
public class ObjectArrayPlus extends ObjectArray implements Iterable<Object> {
/** Konstruktor fuer eine leere Liste
*
* @param maxsize Maximale Groesse
*/
public ObjectArrayPlus(int maxsize) {
super(maxsize);
};
/** Element aus Liste entfernen */
public void remove(int idx) {
for ( int i = idx; i<array.length-1; i++){
array[i]= array[i+1];
}
belegt -= 1;
}
/** Einen Iterator fuer die Liste erzeugen */
public Iterator<Object> iterator() {
return new Iter();
}
/** Implementierung eines Iterators */
public class Iter implements Iterator<Object> {
/** Aktuelle Position */
int position;
/** Konstruktur */
public Iter() {
position = 0;
}
/** Zum naechsten Element gehen */
public Object next() {
Object x = array [position];
for ( int i = position; i<array.length-1; i++){
array [i]= array[i+1];
}
belegt -= 1;
return x;
}
/** Test, ob die Liste ein naechstes Element hat */
public boolean hasNext() {
if (position != belegt) {
return false;
}
return true;
}
/** Entfernen nicht erlaubt. */
public void remove() {
throw new UnsupportedOperationException();
}
}
/** Methode zum Testen der Implementierung */
// Hinweis: in der Praxis wuerde man hier einen Unit-Test verwenden!
public static void main(String[] args) {
ObjectArray liste = new ObjectArray(10);
liste.prepend(2);
liste.prepend(1);
liste.append(3);
liste.append(4);
liste.prepend(0);
System.out.println("Ist die Laenge 5? "+liste.size());
System.out.println("Die naechstes Zeile sollte dies sein: '0 1 2 3 4'!");
System.out.println();
System.out.println();
// TODO: Fuegen Sie einen sinnvollen Test fuer die remove(i) methode hinzu
}
}
|
|
Der Code arbeitet nur, wenn ich den Teil herausschneide. Ich weiß nicht wieso das so ist?
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
|
for (Object i : liste) {
System.out.print(i+" ");
}
System.out.println();
System.out.println("Die naechste Zeile sollte leer sein, aber keinen Fehler verursachen!");
for (Object i : new ObjectArray(10)) {
System.out.print(i+" ");
|
|
|
|
05.05.2015 21:02 |
|
|
Batista
unregistriert
|
|
| Zitat: |
Original von eulerscheZahl
Damit for (Object i : liste) funktioniert, muss liste Iteratable implementieren. Die Klasse ObjectArray tut das aber nicht, sondern erst die abgeleitete Klasse ObjectArrayPlus. Du musst also entweder schon die Elternklasse iterierbar machen, oder liste als ObjectArrayPlus deklarieren. |
Das macht Sinn, doch ich bin der Bedeutung von for (Object i : liste) nicht sicher.
Kannst du bitte erklären?
|
|
|
06.05.2015 19:43 |
|
|
|
|
In anderen Sprachen heißt das Konstrukt foreach, ist meiner Meinung nach treffender.
| code: |
1:
2:
3:
|
for (Object i : liste) {
System.out.print(i + " ");
} |
|
macht das selbe wie
| code: |
1:
2:
3:
|
for(int i = 0; i < liste.size(); i++) {
System.out.print(liste.get(i) + " ");
} |
|
Es wird also über die Elemente der Liste iteriert. Der wesentliche Unterschied zwischen for und foreach ist, dass du bei for auch schreibend zugreifen kannst, bei foreach nur lesend.
Deine liste ist dafür kein gutes Beispiel, nehmen wir einfach ein double[] array:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
|
double[] array = new double[5];
for (int i = 0; i < array.length; i++) {
array[i] = i; // schreibender Zugriff
}
for (double d : array) {
System.out.print(d + " ");
d = 3; // überschreiben
}
System.out.println();
System.out.println(Arrays.toString(array)); |
|
Ausgabe:
| code: |
1:
2:
|
0.0 1.0 2.0 3.0 4.0
[0.0, 1.0, 2.0, 3.0, 4.0] |
|
__________________
Syntax Highlighting fürs Board (Link)
|
|
|
06.05.2015 20:09 |
|
|
Batista
unregistriert
|
|
zur der Main wurde remove ergänzt
Man enthält
0
1
3
4
Wie bekommt das Ergebnis in einer Zeile angezeigt?
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
|
public static void main(String[] args) {
ObjectArrayPlus liste = new ObjectArrayPlus(10);
liste.prepend(2);
liste.prepend(1);
liste.append(3);
liste.append(4);
liste.prepend(0);
System.out.println("Ist die Laenge 5? "+liste.size());
System.out.println("Die naechstes Zeile sollte dies sein: '0 1 2 3 4'!");
for (Object i : liste) {
System.out.print(i+" ");
}
System.out.println();
System.out.println("Die naechste Zeile sollte leer sein, aber keinen Fehler verursachen!");
for (Object i : new ObjectArrayPlus(10)) {
System.out.print(i+" ");
}
System.out.println();
liste.remove(2);
System.out.println("Die naechstes Zeile sollte dies sein: '0 1 3 4'!");
for(int i = 0; i<liste.belegt; i++){
System.out.println (liste.array [i] +" ");
}
System.out.println();
}
}
|
|
|
|
|
06.05.2015 20:24 |
|
|
Batista
unregistriert
|
|
Perfekt 
Ich benutze foreach nur wenn lesend wichtig ist.
Darf man auch for statt foreach benutzen, oder besteht hier die Gefahr, dass an versehentlich ein Objekt/Liste verändert.
|
|
|
06.05.2015 20:32 |
|
|
Batista
unregistriert
|
|
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
|
public static void main(String[] args) {
ObjectArrayPlus liste = new ObjectArrayPlus(10);
liste.prepend(2);
liste.prepend(1);
liste.append(3);
liste.append(4);
liste.prepend(0);
System.out.println("Ist die Laenge 5? "+liste.size());
System.out.println("Die naechstes Zeile sollte dies sein: '0 1 2 3 4'!");
for (Object i : liste) {
System.out.print(i+" ");
}
System.out.println();
liste.remove(2);
System.out.println("Die naechstes Zeile sollte dies sein: '0 1 3 4'!");
for (Object i : liste) {
System.out.print(i+" ");
}
System.out.println();
}
}
|
|
Ich versteh foreach nicht, wird
foreach nur beutz wenn Iteratorwird?
|
|
|
06.05.2015 20:37 |
|
|
Batista
unregistriert
|
|
Wieso wird überhaupt Iterator verwendet? Welche Funktion erfüllt es?
|
|
|
06.05.2015 22:57 |
|
|
Polzi 
Jungspund
Dabei seit: 05.05.2015
Beiträge: 11
Herkunft: Bayern
|
|
Würde mich auch mal interessieren... danke für die Antwort schon mal!
|
|
|
07.05.2015 14:08 |
|
|
Karlito
Kaiser
Dabei seit: 11.04.2011
Beiträge: 1.461
|
|
Hallo,
in der Softwaretechnologie gibt es etwas, das nennt sich Design Pattern (oder auch Entwurfsmuster). Das sind bewährte Muster, welche man immer wieder verwendet.
Der Iterator ist ein solches Entwurfsmuster. Der Vorteil von Iterator ist, dass völlig egal ist, welche Datenstruktur im Hintergrund verwendet wird. Solange das Iterator-Pattern implementiert ist, kann man die Datenstruktur Element für Element durchsuchen. In java wird dadurch die erweiterte for-Schleife (foreach) möglich. Diese verwendet implizit den Iterator.
Was die foreach-Schleife angeht:
| code: |
1:
2:
3:
4:
5:
|
for(Foo foo : foos) {
System.out.println(foo);
}
|
|
ist äquivalent zu:
| code: |
1:
2:
3:
4:
5:
6:
|
Iterator it = foos.getIterator()
while(it.hasNext()){
System.out.println(it.next());
}
|
|
.
Damit man die foreach-Schleife verwenden kann, muss die Datenstruktur, über die iteriert werden soll Iterable (ein Interface) implementieren. Damit ist dann die Methode getIterator() verfügbar. Diese gibt dann ein Objekt vom Typ Iterator zurück (auch ein Interface). Dieses Objekt realisiert dann den Schrittweisen zugriff per .hasNext() und next() auf die Datenstruktur. Wie die Struktur dabei aussieht (Baum, Hashset, LinkedList, Array, ....) ist völlig egal.
Gruß,
Karlito
|
|
|
07.05.2015 15:34 |
|
|
Batista
unregistriert
|
|
Sehr verständlich
@eulerscheZahl
könntest du dir bitte den letzten Code anschauen? Hat man damit die Aufgabe gelöst, wie erwünscht?
|
|
|
07.05.2015 20:02 |
|
|
|
|
Darfst du denn einfach in der main aus ObjectArray ObjectArrayPlus machen? Falls ja, geht das so in Ordnung. Ansonsten musst du eben ObjectArray als Iterable deklarieren.
__________________
Syntax Highlighting fürs Board (Link)
|
|
|
08.05.2015 15:49 |
|
|
Batista
unregistriert
|
|
Das ist soweit die Angabe
directupload.net/file/d/3981/4pjtm7i8_jpg.htm
directupload.net/file/d/3981/rqrg56wd_jpg.htm
Erkennst du an der Aufgabenstellung, wie man machen sollte?
| Zitat: |
Original von eulerscheZahl
Ansonsten musst du eben ObjectArray als Iterable deklarieren. |
deklarieren bedeutet:
Die Klasse ObjectArray implements iterable<Object> ?
remove(0) hat die Komplexität O(1) ?
|
|
|
08.05.2015 19:47 |
|
|
|
|
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
|
public Object next() {
Object x = array [position];
for ( int i = position; i<array.length-1; i++){
array [i]= array[i+1];
}
belegt -= 1;
return x;
} |
|
Hier löschst du Einträge aus der Liste, ein Iterator darf die Liste nicht verändern.
Und das hasNext() lässt sich auch einfacher schreiben.
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
|
/** Zum naechsten Element gehen */
public Object next() {
return array[position++];
}
/** Test, ob die Liste ein naechstes Element hat */
public boolean hasNext() {
return position < belegt;
} |
|
Bei remove(0) werden die übrigen Einträge alle um 1 nach oben geschoben, das heißt du musst jeden Wert im Array überschreiben. Das geht nicht in konstanter Laufzeit, sondern hängt von der Anzahl der Einträge ab (genau wie prepend). Ein append geht dagegen in konstanter Zeit, wenn die Liste nicht vergrößert werden muss.
__________________
Syntax Highlighting fürs Board (Link)
|
|
|
08.05.2015 20:02 |
|
|
|
