Hallo!

Ich rätsle gerade an folgendem Problem rum:
Wie kann ich einer neuen Klasse einen "automatisierten" Namen geben? Also, dass ich nicht für jede Instanz einer Klasse einen Namen selbst bestimmen muss, sondern sie nach einem gewissen Schema benenne.
Ich stelle mir das in etwa wie folgt vor:

Code :

1 2	int x; Klasse x++ = new Klasse();

Geht natürlich so nicht. Aber wie könnte es denn sonst möglich sein?

Bzw.: Ist es überhaupt möglich?


mfg,
Syrill


PS: Ich versuche eine LinkedList selbst zu implementieren und brauche dazu für jedes neue Element (also Klasse) eine Referenzmöglichkeit. Ein (einzigartiger) Name wäre da ideal.

Zitat von Syrill

Bzw.: Ist es überhaupt möglich?

Nein. Das geht in der Form nur in Skript-sprachen.

Du musst eine Liste oder ein Array dafür nehmen.

Edit:

Zitat von Syrill

PS: Ich versuche eine LinkedList selbst zu implementieren und brauche dazu für jedes neue Element (also Klasse) eine Referenzmöglichkeit. Ein (einzigartiger) Name wäre da ideal.

Der Witz an einer verketteten Liste ist ja, dass du nur eine Referenz auf ein einziges Element brauchst (oder auf zwei, bei doppelt verketteter Liste).

Hallo,

schau dir mal ArrayLists an. Damit kannst du beliebig viele Instanzen einer Klasse halten und sie mit der get()-Methode herausholen ohne den konkreten Namen wissen zu müssen.

Grüße
Robert

Danke für eure Antworten!

Zitat von CPoly

Du musst eine Liste oder ein Array dafür nehmen.

Wenn man eine Liste nachzubilden will, wäre es etwas seltsam dafür wieder eine Liste zu nehmen. Also ein Array. Es kann sein, dass ich mich da völlig verrannt habe (um die Uhrzeit kein Wunder), aber wie instanziere ich dann dabei die einzelnen Elemente? Irgendwie muss ich sie dabei ja benennen?!

Zitat von CPoly

Der Witz an einer verketteten Liste ist ja, dass du nur eine Referenz auf ein einziges Element brauchst (oder auf zwei, bei doppelt verketteter Liste).

Ist mir schon klar, aber dafür muss ich das Element ja ansprechen können und zwar von einem anderen Element aus und nicht nur von der "übergeordneten" Listenklasse aus.
In dieser könnte ich sie immer passend in neue Arrays ordnen, aber dann verweißen sie ja nicht selbst aufeinander.

Zitat von Bobblz

schau dir mal ArrayLists an. Damit kannst du beliebig viele Instanzen einer Klasse halten und sie mit der get()-Methode herausholen ohne den konkreten Namen wissen zu müssen.

Ich versuche ja eine Liste nachzubilden, nicht eine zu verwenden...

Ein Array ist dafür ziemlich ungeeignet, weil:
a) Hast du dann keine Liste, sondern eher eine Arrayklasse
b) Zum Hinzufügen/Löschen kannst du immer das gesamte Array neu anlegen, da sich Arrays nicht einfach so vergrößern/verkleinern lassen

Aber bei einer Liste brauchst du sowieso kein Array, du brauchst nur das erste Element. Nur eines.
Ein Element besteht wiederrum aus dem Wert und einem Verweis zum nächsten.
Das zweite hat wieder einen Wert und weiß, wo das dritte ist usw...

Zitat von Syrill

Wenn man eine Liste nachzubilden will, wäre es etwas seltsam dafür wieder eine Liste zu nehmen.

Das hab ich vor deinem PS geschrieben.

Zitat von Syrill

Ist mir schon klar, aber dafür muss ich das Element ja ansprechen können und zwar von einem anderen Element aus und nicht nur von der "übergeordneten" Listenklasse aus.

Deine Klasse "ListenElement" bekommt einfach ein Datenelement vom Typ "ListenElement", welches auf das nächste Zeigt.

Zitat von sheel

Aber bei einer Liste brauchst du sowieso kein Array, du brauchst nur das erste Element. Nur eines.
Ein Element besteht wiederrum aus dem Wert und einem Verweis zum nächsten.
Das zweite hat wieder einen Wert und weiß, wo das dritte ist usw...

Ich habe ja zwei Klassen. Die eine ist für die Verwaltung der ganzen Liste zuständig, inklusive Iterator, add, remove usw. Methoden. Die andere beschreibt ein Element der Liste. Wenn ich jetzt aus der ersten Klasse heraus die zweite Klasse instanziere, um die Liste zu erweitern, dann weiß ich einfach nicht, wie ich auf ein weiteres Element der Liste, also eine andere Instanz der zweiten Klasse verweisen soll, ohne deren Namen zu kennen.
Und vorallem wird es kompliziert, wenn ich dann einfach zwischendrin etwas einfügen will.

Das Konzept einer Liste ist mir klar, nur mit der konkreten Implementierung tue ich mir gerade, wegen des geschilderten Problems, unheimlich schwer.


PS: Oder muss ich alle Elemente immer über das eine definierte Anfangselement ansteuern und dann eben n mal die next-Methode aufrufen, um zu Element n-1 zu kommen? Dann wäre jede Operation inmitten der Liste aber wirklich unschön...

Zitat von CPoly

Das hab ich vor deinem PS geschrieben.

Entschuldigung, das hatte ich übersehen...

Zitat von CPoly

Deine Klasse "ListenElement" bekommt einfach ein Datenelement vom Typ "ListenElement", welches auf das nächste Zeigt.

Ok. Und wie lege ich dann Zeiger um? Indem ich immer von einem Startelement aus durchzähle?

Zitat von Syrill

PS: Oder muss ich alle Elemente immer über das eine definierte Anfangselement ansteuern und dann eben n mal die next-Methode aufrufen, um zu Element n-1 zu kommen? Dann wäre jede Operation inmitten der Liste aber wirklich unschön...

Richtig. So ist eine Liste nunmal.

Um die Performance ein wenig zu verbessern, könnte man bei einer doppelt verketteten Liste (bei der jedes Element das vorne und das danach kennt):
Nicht immer vom Anfangselement ausgehen, sondern einfach sein "Anfangselement" dort haben, wo man als letztes den Wert gebraucht hat.
Man muss natürlich mit einem int mitzählen, beim wievielten Element man vom originalen Anfang aus ist.

Zitat von sheel

Richtig. So ist eine Liste nunmal.

Um die Performance ein wenig zu verbessern, könnte man bei einer doppelt verketteten Liste (bei der jedes Element das vorne und das danach kennt):
Nicht immer vom Anfangselement ausgehen, sondern einfach sein "Anfangselement" dort haben, wo man als letztes den Wert gebraucht hat.
Man muss natürlich mit einem int mitzählen, beim wievielten Element man vom originalen Anfang aus ist.

Ich hatte inzwischen schon daran gedacht eher eine doppelt verkettete zu basteln.

Wenn ich also beispielsweise um 3 "vorrücken" will sähe das in etwa so aus:

Code :

1 2 3 4

for(int i = 0; i < 3; i++) { ElementKlasse.getnext(); } ElementKlasse.next = //beispielsweise jetzt neuen Zeiger einfügen

Und mit der letzten Zeile greife ich dann auf das dritte Objekt nach dem Ursprungsobjekt zu?

Du musst dir "next" in der Schleife auch merken. So in etwas sollte die "get(int i)" Methode aussehen.

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13

public T get(int i) {     if(i >= this.size)         throw new ArrayIndexOutOfBoundsException("Die Liste ist nicht so groß!");         //First ist immer dein Start-Element     ElementKlasse tmp = this.first;         while(i-- > 0) {         tmp = tmp.getNext();     }         return tmp.getValue(); }

Neben "first" bietet sich bei einer doppelt verketteten Liste auch noch "last" an, um je nach Index von hinten anzufangen.

Zitat von Syrill

PS: Oder muss ich alle Elemente immer über das eine definierte Anfangselement ansteuern und dann eben n mal die next-Methode aufrufen, um zu Element n-1 zu kommen? Dann wäre jede Operation inmitten der Liste aber wirklich unschön...

Deshalb steht man auch je nach Anwendungsfall immer vor der Frage, ob man LinkedList oder ArrayList verwendet. Wir hatten dazu mal eine Übungsaufgabe, in der wir beide gegenüberstellen sollten und die Zeit messen. Z.b. eine Millionen Element immer am Ende einfügen, oder eine Millionen Mal einen Index Zugriff machen. Da merkt man ganz schnell, wo die Listen Ihre Schwächen haben.

Also wenn ich beispielsweise ein Element zwischen Element 3 und Element 4 einfügen möchte, dann gehe ich vom Startelement vor, bis ich bei Element 3 bin. Dann Speichere ich den das next-Element zwischen und setzte es für Element 3 auf das neue Element. Dann gehe ich zu dem neuen Element (jetzt das next von Element 3) und gebe dort das zwischengespeicherte als next an.

Bei einer doppelt verketteten Liste muss ich einfach dann noch ein "davor" abspeichern und beim einfügen mehr zwischenspeichern und neu vergeben.

Und ich muss zwischenspeichern, bei welchem Element der Liste ich gerade bin. Oder fange ich immer wieder beim ersten Element an?

Zitat von Syrill

Also wenn ich beispielsweise ein Element zwischen Element 3 und Element 4 einfügen möchte, dann gehe ich vom Startelement vor, bis ich bei Element 3 bin. Dann Speichere ich den das next-Element zwischen und setzte es für Element 3 auf das neue Element. Dann gehe ich zu dem neuen Element (jetzt das next von Element 3) und gebe dort das zwischengespeicherte als next an.

Bei einer doppelt verketteten Liste muss ich einfach dann noch ein "davor" abspeichern und beim einfügen mehr zwischenspeichern und neu vergeben.

Genau.

Zitat von Syrill

Und ich muss zwischenspeichern, bei welchem Element der Liste ich gerade bin. Oder fange ich immer wieder beim ersten Element an?

Bei einfach verketteten sollte man immer wieder vorne anfangen.
Wenn man nur eines in der Mitte kennt, kommt man zu den vorhergehenden ja nicht mehr zurück.

Bei doppelt verketteten kann man es sich aussuchen
Wenn du immer das aktuelle Element statt dem Anfang speicherst, musst du aber noch irgendwo speichern das wievielte Element das ist (wenn du dann zB das insgesamt vierte Element brauchst, musst du ja herausfinden, wieviel vor/zurück du von der aktuellen Position aus gehen musst)

Mit dem aktuellen Element bekommst du vor allem bei Schleifen, in denen du jedes Element durchgehst, bessere Performance. Du musst dann ja immer nur eins weitergehen, statt vom Anfang jedesmal neu loszuzählen.

Eine Möglichkeit, das auch bei einfach verketteten Listen zu machen, wäre, dass das letzte Element als next wieder das erste hat (also sozusagen im Kreis geht).

Gruß

Vielen Dank nochmal für eure Hilfe. Dank euch konnte ich das Ganze wie gewünscht umsetzten.
Ihr habt mir geholfen ein paar Denkfehler zu korrigieren!