[Java - BlueJ] Liste mit Elementen füllen

[kloklojul]

Ich war gerade auf der nibis seite für informatik und fand dort eine Aufgabe.
Die Aufgabe lautet erstelle eine Liste die einige Methoden hat. Genaueres hier

Spoiler: 

Liste()
Eine leere Liste wird angelegt. Der interne Positionszeiger, der das aktuelle Element markiert, wird auf Null
gesetzt.

istLeer(): Wahrheitswert
Wenn die Liste kein Element enthält, wird der Wert wahr zurückgegeben, sonst der Wert falsch.

inhaltGeben(): Inhalt
Der Inhalt des aktuellen Listenelements wird zurückgegeben.

einfuegen(Inhalt inhalt)
Ein neues Listenelement mit dem angegebenen Inhalt wird angelegt und hinter der aktuellen Position in die Liste
eingefügt, alle weiteren Elemente werden nach hinten verschoben. Der interne Positionszeiger steht auf dem neu
eingefügten Element.

einfuegen(Ganzzahl position, Inhalt inhalt)
Ein neues Listenelement mit dem angegebenen Inhalt wird angelegt und an der angegebenen Position in die
Liste eingefügt. Das vorher an dieser Position befindliche Element und alle weiteren Elemente werden nach
hinten verschoben. Der interne Positionszeiger steht auf dem neu eingefügten Element. Falls die angegebene
Position nicht existiert, hat die Operation keine Wirkung.

loeschen()
Das aktuelle Listenelement wird gelöscht. Der interne Positionszeiger steht anschließend auf dem Nachfolger des
gelöschten Elements. Falls kein Nachfolger existiert, zeigt er auf den Vorgänger.

positionGeben(): Ganzzahl
Der Wert des internen Positionszeigers wird zurückgegeben.

positionSetzen(Ganzzahl position)
Der interne Positionszeiger wird auf den angegebenen Wert gesetzt. Falls die angegebene Position nicht existiert,
wird der Positionszeiger nicht verändert.

laengeGeben(): Ganzzahl
Die Anzahl der Elemente in der Liste wird zurückgegeben

Soo nun habe ich erst einmal eine Klasse erstellt die das Element darstellen soll.

Spoiler: 

public class Element {
private Element vorgaenger;
private int wert;
private Element nachfolger;

public Element(Element vorgaenger, int wert, Element nachfolger) {
this.vorgaenger = vorgaenger;
this.wert = wert;
this.nachfolger = nachfolger;
}

public Element getVorgaenger() {
return vorgaenger;
}

public Element getNachfolger() {
return nachfolger;
}

public int getWert() {
return wert;
}

public void setVorgaenger(Element vorgaenger) {
this.vorgaenger = vorgaenger;
}

public void setNachfolger(Element nachfolger) {
this.nachfolger = nachfolger;
}

public void setWert(int wert) {
this.wert = wert;
}
}

Anschließend habe ich ein interface erstellt das einige der geforderten Methode enthällt.

Spoiler: 

public interface IListe{

public boolean istLeer();

public void loeschen();

public int getPosition();

public void setPosition (int position);

public int getLaenge();
}

Jetzt muss ich eine Klasse erstellen die das Interface benutzt, allerdings weiß ich jetzt gar nicht wie ich weiter machen soll. Ich weiß zwar wie das Programm aussehen muss, aber leider weiß ich nicht wie ich es in Java umsetzen kann.
Wen ich die Methode einfuegen aufrufe soll ein Element an der stelle des zeigers erstellt werden und der Vorgänger(da es noch keinen gibt) soll auf null gesetz werden. Das selbe mit Nachfolger. Wie würde zb diese Methode aussehen ?

[TheSplit]

Frage an dich: Warum definierst du das Element?
Definiere die Klasse "Liste".

Das Element wird doch durch die Grundtypen boolean, int, char, byte... oder eben auch String und et cetera definiert.
Du sattelst das Pferd von hinten auf.

Wie ich das sehe solltest du die Klasse der Liste erstellen, diese enthält beispielsweise einen Mengen- und Positionszähler (Cursor/Pointer) die du über das Interface der Liste abfragen kannst und erweitere Funktionen wie "if 0 elemente => isEmpty else return isNotEmpty"..

Schau nochmal die Aufgabenstellung an.

[dynaDE]

Ich sehe das genauso wie TheSplit. Ein großer Teil der Entwicklung fängt sozusagen auf dem Papier statt. Überlege dir ersteinmal was du alles benötigst, erstelle dir ein Konzept. Denn dein Ansatz ist nicht ganz Korrekt.

Du solltest dir z.B. überlegen wie du es schaffst, einzelne Elemente zu verbinden, damit du später durch iterieren kannst. Häufig wird hier eine einfach verkette Liste Methode genutzt (wäre eine Möglichkeit; siehe google für das Prinzip).

Also welche Klassen benötigst du? Welche Instanzvariablen bzw. Klassenvariablen benötigst du? Sind diese variablen private, public, protected oder gemischt und warum sollten sie es sein? Worauf muss das Interface implementiert werden? Gründe?

[kloklojul]

Also ich brauche eigentlich nur 2 Klassen und 1 Inteface .

Spoiler: 

Soweit ich das verstanden hab dient ein Interface als grober Bauplan was die Klasse unteranderem kann. Also muss die Klasse Liste von IListe erben.

Nun hab ich mir gedanken zur einfügen methode gemacht:

Spoiler: 

fügt man nun ein Element ein so verschiebt sich das Element an der angegebenen Stelle nachhinten und der zeiger springt auf das neue Element. Das neue Element beinhaltet den Wert 25 und ist nun der Nachfolger von dem alten Ele., das alte Ele ist nun der Vorgänger von dem neuen. Das neue Element hat keinen Nachfolger deshalb wird der Nachfolger null gesetzt, dass selbe mit dem Vorgänger vom alten Ele..

Also brauch ich sofern ich mich nicht täusche folgende Variablen für diese Methode:

In der Listen-Klasse :
-einen Zeiger (int) public
-einen Positionszähler (int) private

In der Elementen-Klasse:
-eine Variable die den Wert Speichert (zB int) private
-einen Nachfolger (?) public
-einen vorgänger (?) public

Sehe ich das so richtig ?
(Sorry bin noch ein totaller Anfänger ^^')

[TheSplit]

Soweit ich das verstanden hab dient ein Interface als grober Bauplan was die Klasse unteranderem kann. Also muss die Klasse Liste von IListe erben.

Ich war und bin kein Fachinformatiker - aber ein Interface ist im englischsprachigen etwas was man bedient. Daraus also abgeleitet etwas was Funktionen beinhaltet die sich bedienen lassen - zur (Daten)Eingabe, Vearbeitung und Ausgabe (EVA-Prinzip).

Nun hab ich mir gedanken zur einfügen methode gemacht:
...
fügt man nun ein Element ein so verschiebt sich das Element an der angegebenen Stelle nachhinten und der zeiger springt auf das neue Element. Das neue Element beinhaltet den Wert 25 und ist nun der Nachfolger von dem alten Ele., das alte Ele ist nun der Vorgänger von dem neuen. Das neue Element hat keinen Nachfolger deshalb wird der Nachfolger null gesetzt, dass selbe mit dem Vorgänger vom alten Ele..

Sagt dir "push" und "pop" etwas?
Stell dir vor du stapelst Bücher. Am Anfang ist der Stapel leer (bzw. gar nicht da, du kreiirst in). Nun legst du das erste Buch auf einen Tisch.Nun noch eines oben drauf. Das erste Buch bleibt aber an seiner Stelle, es kommen alle anderen Bücher also "oben drauf" (push) ohne das sich etwas bewegt..

Ich finde auch den Satz aus der Aufgabenbeschreibung aber ABSOLUT IRREFÜHREND:

"einfuegen(Inhalt inhalt)
Ein neues Listenelement mit dem angegebenen Inhalt wird angelegt und hinter der aktuellen Position in die Liste
eingefügt, alle weiteren Elemente werden nach hinten verschoben. Der interne Positionszeiger steht auf dem neu
eingefügten Element."

Um es nicht anders zu sagen, das IST blödsinn, weil die Liste nur in eine Richtung wachsen kann (unser Bücherstapel) nach OBEN (push push push ->>>). Selbst wenn du Inhalt in der Mitte einfügst (ein Buch dazwischen legst) der Stapel wächst nach oben.

Also brauch ich sofern ich mich nicht täusche folgende Variablen für diese Methode:

In der Listen-Klasse :
-einen Zeiger (int) public
-einen Positionszähler (int) private

In der Elementen-Klasse:
-eine Variable die den Wert Speichert (zB int) private
-einen Nachfolger (?) public
-einen vorgänger (?) public

Sehe ich das so richtig ?

Auch hier frage ich dich, aus welcher der Funktionen der Aufgabenstellung liest du das jedes Element (oder Buch) seine n Nachbarn kennen muß?? Das ist den Daten, in diesem Fall doch egal.

Schau dir mal die in Java verfügbaren Grunddatentypen wie auch Kollektionen (Collections) an.
Beispiel das Array: Array / Feld auf Wikipedia

[hartweizen]

Ich war und bin kein Fachinformatiker - aber ein Interface ist im englischsprachigen etwas was man bedient. Daraus also abgeleitet etwas was Funktionen beinhaltet die sich bedienen lassen - zur (Daten)Eingabe, Vearbeitung und Ausgabe (EVA-Prinzip).

In OOP bzw. noch spezifischer in Java ist ein Interface etwas enger gefasst, davon redet der OP. (Schnittstelle (OOP))

Wobei man in Java nicht von einem Interface erbt sondern es implementiert.

Sagt dir "push" und "pop" etwas?
Stell dir vor du stapelst Bücher. Am Anfang ist der Stapel leer (bzw. gar nicht da, du kreiirst in). Nun legst du das erste Buch auf einen Tisch.Nun noch eines oben drauf. Das erste Buch bleibt aber an seiner Stelle, es kommen alle anderen Bücher also "oben drauf" (push) ohne das sich etwas bewegt..

In der Aufgabenstellung ist was von Liste zu lesen.
Nix von Stack oder (ich hasse das Wort) "Kellerspeicher".

Ich finde auch den Satz aus der Aufgabenbeschreibung aber ABSOLUT IRREFÜHREND:


Um es nicht anders zu sagen, das IST blödsinn, weil die Liste nur in eine Richtung wachsen kann (unser Bücherstapel) nach OBEN (push push push ->>>). Selbst wenn du Inhalt in der Mitte einfügst (ein Buch dazwischen legst) der Stapel wächst nach oben.

Liste != Stack

Eine Liste kann durchaus wenn gefordert auch in 2 Richtungen wachsen, meist nicht gefordert (hier wohl auch nicht), aber durchaus möglich.
Und Listen wachsen eher nicht nach "oben" oder "unten" sondern Elemente werden eingefügt, je nachdem wo kann man dann festlegen ob und wenn ja wohin sich andere Elemente dann bewegen (müssen).
Die Aufgabenstellung ist da auch relativ klar formuliert.

Auch hier frage ich dich, aus welcher der Funktionen der Aufgabenstellung liest du das jedes Element (oder Buch) seine n Nachbarn kennen muß?? Das ist den Daten, in diesem Fall doch egal.

Wenn der OP seine Liste als verkettete Liste implementieren will, warum nicht?

Wenn er ein Element der Liste inkl. Vorgänger und Nachfolger als eigene Klasse implementieren will, warum (außer das es auch kompakter/kürzer ginge) nicht?

Schau dir mal die in Java verfügbaren Grunddatentypen wie auch Kollektionen (Collections) an.
Beispiel das Array: Array / Feld auf Wikipedia

Wenn er sich Klassen aus den Java-Collections anschauen sollte, dann doch wohl Listen die auch wachsen dürfen, mit dem normalen Array das in Java einmal definiert wird und dann eben nicht wächst wird er da nicht weit kommen.
Liste (Datenstruktur) (eigentlich ist der Link schon viel zu hilfreich)

Abgesehen davon sollte das nur Anschauungsmaterial für seinen selbstgewählten Ansatz sein, eine Liste die zur Runtime wachsen kann mit einer schon fertigen Liste die zur Runtime wachsen kann zu implementieren sollte keine große Kunst sein.

Den Ansatz des OP eine verkettete Liste bauen zu wollen und dafür erst mal ein Interface zu definieren und dann ein einzelnes Element/Knoten (inkl. Verkettung zu den Nachbarn) zu modellieren finde ich für einen Anfänger schon mal gar nicht schlecht.

Ein wenig ambitioniert und vielleicht ein wenig over-engineered aber ich würde ihm den Ansatz mit der Modellierung des Elementes im Gegensatz zu den meisten anderen hier nicht ausreden wollen.

Wenn seine Lösung am Ende funktioniert hat er sein Ziel erreicht.

[TheSplit]

Hallo hartweizen,

ich wollte ihn mit dem Array Ansatz auch eher in Richtung ArrayList schubsen da diese auch während der Laufzeit wachsen kann. Vielleicht denke ich auch einfach zu kompakt oder pythonisch - aber was ich an deiner Aussage nicht logisch nachvollziehen kann ist der Punkt das Elemente in einer Liste sich auch nach "hinten" verschieben. Ich sehe da keinen effektiven nutzen für, als "Laie". (siehe Edit unten)

Natürlich kann er auch die Elemente als Klassen definieren und muß dann Vorgänger wie Nachfolger entsprechend in den beiden Nachbar-Elementen updaten. Ginge es aber nicht schneller und vor allem mit weniger Datenaufwand einfach die Werte des Vor- und Nachfolgers "by demand" abzufragen? Liese sich meiner Meinung nach leichter implementieren und nutzt auch weniger Speicher da diese Werte nicht extra in Elementen abgespeichert werden müssen. Und viel Overhead sollte es nicht sein der beim Aufruf der "Ermittler-Funktion" verwendet wird. Letztendlich ist dies doch nur eine Speicheraddress-Abfrage.

Würde er eine Self-organizing-List implementieren welche unter anderem auch die Zugriffe zählt und Elemente entsprechend der Häufigkeit der Abfragen anordnet um diese für "ist Element in Liste"-Funktionen (oder rekursive Iteratitionen) zu optimieren wäre der Aufwand doch eher nachvollziehbar.

Das Array, ArrayList und Stack push/pop-Prinzip habe ich etwas durcheinandergewürfelt - der Unterschied ist mit aber klar (von Java zu Python oder C).

Aber damit ich auch noch etwas schlauer werde, kannst du mir ein konkretes Anwendungsbeispiel für eine sinnvolle Verwendung einer nach "hinten" wachsenden Liste nennen?*


Edit: Okay, der Wikipedia Artikel hat mich zumindest bezüglich der verketteten Liste überzeugt, an eine Neuanordnung beim Löschen von Elementen hatte ich diesem Fall nicht gedacht (ArrayList bzw. Array...). Jetzt macht es aber auch Sinn das die Liste nach "hinten" wächst bzw. wachsen kann (wie du sagst ist ja != Stack ).
Danke!

[hartweizen]

Beispiele wo man Listen braucht die in bestimmte "Richtungen" wachsen können wären Listen deren Reihenfolge gleich bleiben soll/muss wo man aber Elemente einfügen können will.

Beispielsweise eine FIFO-Queue, wo man halt im Gegensatz zu einer LIFO-Queue eben keinen Stack wählen würde.

Oder eine Liste soll sortiert sein aber es müssen Elemente an der "richtigen" Stelle eingefügt werden, dann kann es auch wichtig sein das eine Liste in die richtige "Richtung" wachsen bzw. dessen Elemente in die richtige Richtung geschoben werden können.

Wie man solche Listen dann konkret implementiert ist eine andere Frage.

Der OP hat (vielleicht ohne es zu wissen?) den Ansatz einer doppelt verketteten Liste gewählt.

Nicht der einfachste aber sicher nicht der schlechteste Ansatz.

[dynaDE]

@kloklojul: Hast du fein gemacht *kopftätschel*

Das UML Diagramm ist zwar nicht ganz korrekt, aber der Ansatz ist richtig und das zählt ja.

In der Listen-Klasse :
-einen Zeiger (int) public
-einen Positionszähler (int) private

In der Elementen-Klasse:
-eine Variable die den Wert Speichert (zB int) private
-einen Nachfolger (?) public
-einen vorgänger (?) public

Dazu eine Fragen, warum muss deiner Ansicht nach der Zeiger öffentlich zugänglich sein? Ich denke nicht, dass dieser öffentlich sein muss bzw. sollte.

Zu dem Vorgänger/Nachgänger muss man sagen, dass es schon so funktioniert wie du es geplant hast, i.d.R. nutzt man dafür aber eher setter/getter Methoden.

Aber ansonsten ist das doch schon ein wesentlich besserer Ansatz als der Erste - Ich finde den Ansatz mit einer verketteten Liste auch gut - da lernt du wesentlich mehr, als wenn du irgendwelche fertigen Collections aus dem Framework nutzt.

Zum Interface sei zusagen, dass man es eigentlch wortwörtlich übersetzen kann. Denkt man an ein Interface von bspw. einem Backofen, sehen wir dort Knöpfe und Einstellungsmöglichkeiten die wir "öffentlich" nutzen/bedienen können. Wir wissen jedoch nicht, was der Backofen intern noch so alles schönes macht bzw. besitzt. So ist es auch mit dem Interface. Wie schon gesagt, dass Interface definiert eine Schnittstelle

[kloklojul]

Zum Interface sei zusagen, dass man es eigentlch wortwörtlich übersetzen kann. Denkt man an ein Interface von bspw. einem Backofen, sehen wir dort Knöpfe und Einstellungsmöglichkeiten die wir "öffentlich" nutzen/bedienen können. Wir wissen jedoch nicht, was der Backofen intern noch so alles schönes macht bzw. besitzt. So ist es auch mit dem Interface. Wie schon gesagt, dass Interface definiert eine Schnittstelle

Na das ist doch mal ein vergleich , aufgrund des dummen Klausurenblockes habe ich leider nur wenig Zeit aber am Wochenende setzte ich mich hin und versuch den schman irgentwie hinzubekommen ^^

[dynaDE]

Ja viel Spaß, ich hatte zu meiner Studienzeit eine sehr ähnliche Aufgabe

Um nochmal die Sinn eines Interfaces klarzustellen.

1) Alle definierten Methoden/Properties/Events etc. innerhalb eines Interface, müssen bei der Klasse, die das Interface implementiert angeboten werden. Damit möchte man Sicherstellen, dass sozusagen (zumindest) die Signatur der Klasse (mind.) gleich dem Interface ist.

2) Interface Driven Design (IDD). Über Interfaces MIND. Funktionalitäten von Klassen/Objekten abbilden die implementiert werden sollten. D.h überge ich einer externe Funktion z.B.

interface IMeinInterface {
     string SayHelloToMe (string MyName);
     int Counter { get; set; }     
}

public void foo (IMeinInterface Obj) {
    // do something
} 

Ich kann mit dem Obj schon mehr oder weniger Arbeiten, selbst wenn noch keine Klassen oder Klassen das Interface implementiert haben. D.h. ich kann auf Funktionalitäten zumindest in der IDE drauf zugreifen, Zur Laufzeit knallt es natürlich - aber ich kann durch dieses Muster schon etwas weiter "denken/planen".

3) Kapselung - Klar, ein Interface kann durch mehrere verschiedenen Klassen implementiert werden, sie implementieren ja sozusagen dieselbe Signatur. Ebenso kann ich die einzelnen Implementierungen einfach austauschen