Also ich soll eine eigene Verkettete Liste schreiben, mit diesem Generics gedöhns Is grad neu in der Vorlesung. Dazu noch ne Klasse ListenElement<T>.
Soweit sogut, hab mich im Inet schlau gemacht, was gefunden und mal angefangen.
Verkettete Listen sollen ja Vorgänger und Nachfolger haben, hab mir das ganze dann so vorgestellt:

ListenElement<T>

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

package aufgabe1;   public class ListenElement<T> {         private T object;     private ListenElement<T> nachfolger;     private ListenElement<T> vorgänger;         public ListenElement()     {         }         public ListenElement(T object)     {         this.object=object;     }         public ListenElement<T> getVorgänger()     {         return this.vorgänger;     }         public ListenElement<T> getNachfolger()     {         return this.nachfolger;     }         public void setVorgänger(ListenElement<T> element)     {         this.vorgänger=element;     }         public void setNachfolger(ListenElement<T> element)     {         this.nachfolger=element;     }   }

Dürfte denk ich passen. Das Problem jetzt mit der Liste selber:

VerketteteListe<T>:

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

package aufgabe1;   import java.util.*;   public class VerketteteListe<T> extends AbstractList<T> {       private ListenElement<T> start;     private ListenElement<T> ende;         public VerketteteListe()     {         start = new ListenElement<T>();         ende = new ListenElement<T>();         start.setVorgänger(null);         start.setNachfolger(ende);         ende.setVorgänger(start);         ende.setNachfolger(null);     }           public int size()     public boolean add(T element)     public void add(int index, T element)     public void clear()     public T get(int index)     public T remove(int index)     public T set(int index, T element)   }

Rümpfe hab ich weggelassen, sind imo eh leer.
Am Anfang hat die Liste ja Anfang und Ende (habs im Inet so gelesen).
Vorm Anfang is nix (null) und nach dem Ende halt au nix.
Aber wie geht nun weiter? Wie fülle ich die Rümpfe?
bei size() habe ich mir z.B. gedacht, sowas wie gehe immer weiter zum nächsten Nachfolger und zähle nen Zähler immer um 1 hoch, bis der Null Pointer kommt.
Da dies ja über Generics läuft, kann ich dort nicht einfach t.getnachfolger() machen...

btw: Die Methoden müssen nach Aufgabe alle implementiert (überschrieben) werden.
Ich darf in dieser Aufgabe keine Collection oder Arrays verwenden.

Ich hoffe ihr versteht iwie wo mein Problem liegt

Deine Idee für size() ist völlig korrekt. Aber dein Problem mit t.getnachfolger() verstehe ich nicht, aber Generics sind ja auch neu für dich.

Hier mal beispielhaft die size() Methode

Code java:

1 2 3 4 5 6 7 8 9

T tmp = this.start; int counter = 0;   while(tmp != null) {     tmp = tmp.getNachfolger();     counter++; }   return counter;

Ich würde deine "VerketteteListe" Klasse noch etwas ändern. Aktuell hat diese ja von Beginn an zwei Elemente. Ich würde Sie am Anfang leer lassen (start und ende auf null).


Edit: Üblicherweise brauchst du in der size() Methode gar nichts zu programmieren, sondern du zählst in add(), remove() und clear() einfach die Anzahl mit.

Danke, für die Antwort, ich schau mal mit deim Code das ich die Syntax für die andren schaff.
Falls noch fragen aufkommen editier ichs rein.
Die Size muss rein, da die durch das extends als abstact von Collection kommt.

Edit:: Kann es sein, das ich bei jeder Methode eigentlich nur Start setze und dann so mit einer while schleife durchgehe? also z.B. bei add dann genau das gleiche, bis der pointer null sagt, und dann das element nehmen, was den nullpointer wirft, und nachfolger setzen, richtig?


Edit2:: hier schon das erste problem:

Code :

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

public boolean add(T element)     {         ListenElement<T> elem = this.start;                   while(elem != null)         {             elem = elem.getNachfolger();         }         elem.setNachfolger(element);         element.setNachfolger(null);                   return true;     }

Die Nachfolger sind ungültig, da der Typ nicht stimmen würde ...
Ist wohl alles bischen anders mit den Generics

Ich finds eh sinnlos die VerketteteListe mit <T> zu machen wenn ja eh ListElement<T> daa rein soll ... naja ...

Dass du die Methode "size()" brauchst kann ja sein, aber das heißt nicht, dass du nicht intern die Größe mit zählen kannst und in der Methode nur "return this.size" schreibst.


Der Nachfolger muss vom Typ ListElement<T> sein und nicht vom Typ T.

Code java:

1 2 3 4 5

//falsch elem.setNachfolger(element);   //richtig elem.setNachfolger(new ListenElement<T>(element));

ok, also muss ich ganz genau aufpassen dabei, hab das einfach übersehen bzw nicht gemerkt was ich ändern muss. ok hat alles ganz gut geklappt bis jetz, hab nur grad gemerkt das ich bei add etc auch noch das objekt als nachfolger vom vorgänger setzen muss ... hach is das ein wirr warr

Zitat von I2oxxi

hab nur grad gemerkt das ich bei add etc auch noch das objekt als nachfolger vom vorgänger setzen muss ... hach is das ein wirr warr

Ja, das sind halt die Grundlagen . Listen, Bäume, Graphen etc. sollte man alles mal selbst implementiert haben.

Ja, hab schon viel gemacht, nur Java nie wirklich hab vorher 4 Jahre c und c++ programmiert aber jetzt durchs Studium muss ich Java.
Und Generics, wie ich jetzt gelesen habe gibt es zwar in C++, sind mir aber nie unter die Augen gekommen




Hab jetzt alle Methoden fertig, kann aber leider nix testen, in der add is noch ein Fehler ...

Code :

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

public boolean add(T element)     {         ListenElement<T> elementInList = this.start;                   while(elementInList != null)         {             elementInList = elementInList.getNachfolger();         }         ListenElement<T> dranhängen = new ListenElement<T>(element);         elementInList.setNachfolger(dranhängen);         dranhängen.setVorgänger(elementInList);         dranhängen.setNachfolger(null);                   return true;     }

elementInList.setNachfolger(dranhängen); -> Can only be null at this location


komischerweise hab ich das hier nicht:

Code :

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

public void add(int index, T element)     {         ListenElement<T> elementInList = this.start;                   for(int i=0;i<index;i++)         {             elementInList = elementInList.getNachfolger();         }         ListenElement<T> dranhängen = new ListenElement<T>(element);         elementInList.setNachfolger(dranhängen);         dranhängen.setVorgänger(elementInList);         dranhängen.setNachfolger(null);     }

wobei dies am ende trotzdem ne NullPointerException schmeißt

btw: bei start und ende im konstruktor steht jetz nurnoch wie du vorgeschlagen hast
start=null;
ende=null;

sind aber halt in der klasse als private ListenElement<T> deklariert

Kanns du mir vllt auch verraten wieso die abstrackte Methode add(T) bool zurückgibt?
könnte mir höchsten vorstellen das mir try zu machen und true zurück wenns geklappt hat, aber wieso hat add(index,T) dann nur void?
Scheins dich ja gut auszukennen

Naja, wenn du ein Element an Stelle 10 einfügen willst, aber nur 5 Elemente in der Liste sind, läuft die Schleife in die NULL rein. Deshalb solltest du die Zahl der Elemente mitzählen und darauf prüfen.

Code java:

1 2 3 4 5 6 7

public void add(int index, T element) {     if(index > this.numElements) {         throw new ArrayIndexOutOfBoundsException("You can't add an Element add position " + index);     }       //Dein Code }

ja, sowas kenn ich ja, meine for schleife läuft doch aber über den index, worauf ich in der main selbs noch bestimme wos geaddet wird. und v1.add(0,s1); gibt mir schon ne nulltpointerexception (s1 is ein objekt, v1 die liste).
Und die boolean add(obj) geht ja ans ende und will dranhängen.

ich glaube ich hab den fehler gefunden.
start ist ja null
elementinliste ist start
elementinliste läuft durch
elementinliste wird letztes element bzw element am index
elementinliste.addnachfolger(obj)

da es mal null war kann es die methoden nicht anwenden, weil nie eine instanz erstellt wurde.
hier sollte ich die methoden von ListElement<T> dann static machen, oder?
Oder bin ich jetzt komplett auf nem falschen dampfer?
habe meine ich in der letzten vorlesung nachmal den satz gehört, das static da ist um ne methode ohne gebildete instanz aufzurufen.
hab nie gerafft wofür static ist habs nie gebraucht aber das war doch dafür um methoden ohne instanz zu nutzen richtig?

static hilft dir da nichts. Was du machen muss ist einfach eine Sonderbehandlung für den Fall, das start/nde == null ist.

Code java:

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

public void add(int index, T element) {     //Index Prüfung         //Sonderfall bei leerer Liste     if(this.start == null) {         this.start = this.ende = new ListenElement<T>(element);         return;     }       //Schleifen Kram }

Ichglaube jetzt reden wir grade aneinander vorbei, jedenfalls weiß ich nicht was deins helfen soll.
Habs aber trotzdem ausprobiert, kommt immernoch das selbe

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

public void add(int index, T element)     {         if(index > this.size())         {             throw new ArrayIndexOutOfBoundsException("You can't add an Element add position " + index);         }                 if(this.start == null)         {             this.start = this.ende = new ListenElement<T>(element);             return;         }         ListenElement<T> elementInList = this.start;                   for(int i=0;i<index;i++)         {             elementInList = elementInList.getNachfolger();         }         ListenElement<T> dranhängen = new ListenElement<T>(element);         elementInList.setNachfolger(dranhängen);         dranhängen.setVorgänger(elementInList);         dranhängen.setNachfolger(null);     }

das Problem ist ja kein outofbounds, wie schon gesagt, sowas wird bei mir ja durch eigene eingabe in der main noch bestimmt, und die boolean add() ohne index, die hinten dranhängt, hat ja das selbe problem.
start und ende sind ja so oder so auf null, hab ich ja auf deine empfehlung noch auf null gesetzt.

das elementinlist.setnachfolger(dranhängen) schmeißt ne nullpointer, eclipse warnt auch schon "can only be null at this location"

Kannst du die ganze Klasse samt main mal zeigen? Ich kann dir jetzt mit den paar Zeilen nicht weiter helfen.

Klar:

ListenElement:

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

package aufgabe1;   public class ListenElement<T> {         private T object;     private ListenElement<T> nachfolger;     private ListenElement<T> vorgänger;         public ListenElement()     {         }         public ListenElement(T object)     {         this.object=object;     }         public ListenElement<T> getVorgänger()     {         return this.vorgänger;     }         public ListenElement<T> getNachfolger()     {         return this.nachfolger;     }         public void setVorgänger(ListenElement<T> element)     {         this.vorgänger=element;     }         public void setNachfolger(ListenElement<T> element)     {         this.nachfolger=element;     }   }

VerketteteListe:

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 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110

package aufgabe1;   import java.util.*;   public class VerketteteListe<T> extends AbstractList<T> {       private ListenElement<T> start;     private ListenElement<T> ende;         public VerketteteListe()     {         start = null;         ende=null;     }           public int size()     {         ListenElement<T> element = this.start;         int counter = 0;                   while(element != null) {             element = element.getNachfolger();             counter++;         }                   return counter;     }         public boolean add(T element)     {         if(this.start == null)         {             this.start = this.ende = new ListenElement<T>(element);             return false;         }         ListenElement<T> elementInList = this.start;                   while(elementInList != null)         {             elementInList = elementInList.getNachfolger();         }         ListenElement<T> dranhängen = new ListenElement<T>(element);         elementInList.setNachfolger(dranhängen);         dranhängen.setVorgänger(elementInList);         dranhängen.setNachfolger(null);                   return true;     }         public void add(int index, T element)     {         if(index > this.size())         {             throw new ArrayIndexOutOfBoundsException("You can't add an Element add position " + index);         }                 if(this.start == null)         {             this.start = this.ende = new ListenElement<T>(element);             return;         }         ListenElement<T> elementInList = this.start;                   for(int i=0;i<index;i++)         {             elementInList = elementInList.getNachfolger();         }         ListenElement<T> dranhängen = new ListenElement<T>(element);         elementInList.setNachfolger(dranhängen);         dranhängen.setVorgänger(elementInList);         dranhängen.setNachfolger(null);     }         public void clear()     {         ListenElement<T> element = this.start;                   for(int i=0; i<this.size();i++)         {             element=null;             element = element.getNachfolger();         }     }         public T get(int index)     {         ListenElement<T> element = this.start;         for(int i=0; i<index;i++)         {             element = element.getNachfolger();         }                 T t = (T) element;                 return t;     }         public T remove(int index)     {         return null;             }         public T set(int index, T element)     {         return null;     }   }

Simulierung aka Main(Da schneid ich jetz mal das grundlegende raus, ich hab objekte der klasse studen bli bla blub die heißen s1 s2 s3)

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

package aufgabe1;   import java.util.ArrayList;   public class Simulierung {         public static void main(String[] args)         {         VerketteteListe<Student> v1 = new VerketteteListe<Student>();                 v1.add(0,s1);         v1.add(1,s2);         v1.add(2,s3);                 System.out.println(v1.size());                     }   }

ich denke ich kann das anfang/ende wohl doch nicht einfach null setzen, daher kommt das wohl.
weil objekt, was null ist, kann ja schlecht dann nachfolger() aufrufen


Edit:: Hab jetzt selber noch ein bischen rumgebastelt um das ganze ander zu gestalten, so erscheint mir das eig auch ziemlich logisch, klappt aber trotzdem nicht:

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 boolean add(T element)     {         ListenElement<T> elementInList = this.start;                   while(elementInList != null)         {             elementInList = elementInList.getNachfolger();         }                 ListenElement<T> dranhängen = new ListenElement<T>(element);                 dranhängen.setVorgänger(elementInList);                 if(dranhängen.getVorgänger()==null)         {             this.start = new ListenElement<T>(element);             this.start.setVorgänger(null);             this.start.setNachfolger(null);             return true;         }         else         {             dranhängen.setNachfolger(null);             dranhängen.getVorgänger().setNachfolger(dranhängen);             return true;         }     }

Hi,
du kannst dir auch mal die Klasse Vector ansehen zu dem Thema. Vielleicht kannst du davon ein wenig abkupfern.

Gruß

Fabio

Ganz einfach

Code javascript:

1 2 3 4 5

//Vorher for(int i=0; i < index; i++)   //Nachher for(int i=0; i < index - 1; i++)

Und das Problem bei add (ohne index) ist das gleiche. Du läufst genau ein Element zu weit. Aber üblicherweise würde man das so machen:

Code java:

1 2 3 4

public boolean add(T element) {     return add(size(), element); }