Generics ... VerketteteListe<T> extends ArrayList<T>

[I2oxxi]

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

	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"

 

[CPoly]

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

 

[I2oxxi]

Klar:

ListenElement:

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:

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)

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:

	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;
		}
	}

 

[Fabio Hellmann]

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

Gruß

Fabio

 

[CPoly]

Ganz einfach

//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:

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

 

[I2oxxi]

ändert leider nix, immernoch gleiche ausgabe.
wäre mid -1 ja aber auch unlogisch der index fängt ja bei 0 an, und wenn man 0 übergibt wäre for(int i=0; i < 0-1;i++), womit die schleife übersprungen wird, genau wie bei index 1.
wie gesagt, das problem ist nicht outofbounds.
ich hab da grad ne idee, das das alles nicht klappt weils über nen start pointer läuft, ich versuch grad was umzubauen das ein hilfsobjekt erstellt wird, das sich wie start verhält, und das es dann dadrüber die schleife durchgeht

 

[CPoly]

Ich rate ja nicht rum. Ich kann es mit den Änderungen kompilieren, Elemente einfügen und bekomme die korrekte Anzahl ausgegeben.

 

[I2oxxi]

hm also ich hab deins übernommen und bekam immernoch die falsche anzahl.
jedoch habe ich es jetzt so umgeschrieben, das es bei mir funktioniert:

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

Edit:: meine add(index,obj) klappt jetzt auch, da konnte ich dine index-1 gebrauchen

	public void add(int index, T element)
	{
		ListenElement<T> elementInList = this.start;
		if(index==0)
		{
			if(elementInList==null)
			{
				this.start = new ListenElement<T>(element);
				this.start.setNachfolger(null);
				this.start.setVorgänger(null);
			}
			else
			{
				ListenElement<T> hilfselement = new ListenElement<T>(this.start.getObj());
				
				hilfselement.setNachfolger(this.start.getNachfolger());
				hilfselement.setVorgänger(this.start);
				this.start.setObj(element);
				this.start.setVorgänger(null);
				this.start.setNachfolger(hilfselement);
				
				
				
			}
		}
		else if(index==1)
		{
			ListenElement<T> myElement = new ListenElement<T>(element);
			myElement.setVorgänger(this.start);
			myElement.setNachfolger(this.start.getNachfolger());
			if(this.start.getNachfolger()!=null)
			{
				this.start.getNachfolger().setVorgänger(myElement);
			}
			this.start.setNachfolger(myElement);
		}
		else
		{
			for(int i=0; i<index-1; i++)
			{
				elementInList=elementInList.getNachfolger();
			}
			ListenElement<T> myElement = new ListenElement<T>(element);
			myElement.setVorgänger(elementInList);
			if(elementInList.getNachfolger()==null)
			{
				myElement.setNachfolger(null);
			}
			else
			{
				myElement.setNachfolger(elementInList.getNachfolger());
				elementInList.getNachfolger().setVorgänger(myElement);
			}
			elementInList.setNachfolger(myElement);
			
		}
		
	}

Edit2::
Ich hab da nochmal ne ganz Java spezifische frage. clear soll ja die liste löschen. Wie läuft das jetzt mit dem Garbage Collector ab? Objekte kann man ja nicht selbs löschen, richtig?
heißt, für clear muss ich eigentlich nur start=null machen, und da so keine verbindungmehr besteht, da der startpointer leer is wird ja die ganze liste leer, die objekte werden dann von allein gelöscht da sie nicht mehr genutzt werden?


Edit::
Ok, ich habe jetzt alle methoden fertig und alles klappt, das einzige was zu fehlern in der liste führt ist wenn ich add(0,obj) mache, wenn schon ein objekt auf null liegt, also das objekt an die erste stelle gesetzt werden soll (als start) und dann das vorherige start element folgt.
bei 0 klappt iwas nicht da verhaut der mir die ganze liste.
ist jetzt nur der ausschnitt für den fall 0, hab ja mit if ein paar sonderfälle extra behandelt

public void add(int index, T element)
	{
		ListenElement<T> elementInList = this.start;
		if(index==0)
		{
			if(elementInList==null)
			{
				this.start = new ListenElement<T>(element);
				this.start.setNachfolger(null);
				this.start.setVorgänger(null);
			}
			else
			{
				elementInList=new ListenElement<T>(this.start.getObj());
				elementInList.setNachfolger(this.start.getNachfolger());
				this.start.setObj(element);
				this.start.setNachfolger(elementInList);
				this.start.setVorgänger(null);
				elementInList.setVorgänger(this.start);
			}
        }
    }

eigentlich kommen halt noch fall für index=1 und index > 1 aber das hab ich jetz mal weggelassen, das funktioniert alles. nur bei add(0,obj) wenn schon was auf 0 existiert nicht .... also muss der fehler in dem else block liegen. hab auch schon mit this.start = new ListenElement<T>(element); versucht aber des klappt au nich, da verhauts mir auch die liste