# Eigene simple List-Klasse programmieren



## nrg (13. Jan 2010)

Hallo Zusammen.

ich möchte eine sehr simple einseitig verkettete ListKlasse programmieren. Naja ich poste einfach mal meinen, vllt etwas wirren, kläglichen versuch xD


```
public class ListElement<T> {
	private ListElement<T> nextReference;
	private ListElement<T> root;
	private T data;
	
	public ListElement(){
		
	}
	public ListElement(T obj){
		data = obj;
	}
	public void add(T obj){
		ListElement<T> newElement = new ListElement<T>(obj);
		if (root == null){
			root = newElement;
			nextReference = null;
		}
		else{
			nextReference = newElement;
		}
	}
	public T next(){
		return nextReference.data;
	}
	public boolean hasNext(){
		if (nextReference == null){
			return false;
		}
		return true;
	}
}
```

die Verkettung funktioniert allerdings noch nicht so wie ich mir das vorstelle.
folgender Test:

```
public static void main(String args[]){
		ListElement<String> test = new ListElement<String>();
		test.add("Test1");
		test.add("Test2");
		test.add("Test3");
		while (test.hasNext())
			System.out.println(test.next());
	}
```
gibt nur Test3 aus und endet in einer Dauerschleife xD.

kleine Tipps hier wären super.

danke und grüße
nrg


----------



## anonym (13. Jan 2010)

```
nextReference = newElement;
```

ueberschreibt den Verweis auf das erste Element, das eingefuegt wurde, sobald du ein Zweites einfuegst. Kann es sein, dass du das Ding lieber in nextReference adden solltest? 

Außerdem: root heißt Wurzel, vom Namen her also das erste Element deiner Kette. Aber warum fuegst du dann das erse was geadded wird in root ein? Muesste nicht eigentlich das Element zu dem geadded wird Root des geaddeten werden? bzw. dem geaddeten denselben Root geben, wie es selbst hat?


----------



## SlaterB (13. Jan 2010)

hasNext() fragt nur nextReference ab, welches aber während der while-Schleife der Ausgabe nie verändert wird,
daher Endlosschleife,
was soll man dir da groß erklären?

offensichtlich musst du am Anfang anfangen und dann auch zustandsmäßig irgendwann zum Ende kommen,
z.B. pro Schleifendurchgang eine lokale Variable auf den Nachfolger setzen oder ähnliches,


dann fällt auch auf, dass die Elemente untereinander verlinkt sein müssen,
mit gerademal zwei Referenzen/ Variablen, root + nextReference kannst du kaum mehr als zwei Elemente vorhalten

edit: ok, die Liste selber ist ja das Element, dann wäre die next-Verknüpfung machbar, wenn man sie verwendet,
dann brauchst du aber kaum ein root


----------



## nrg (13. Jan 2010)

also die verkettung hab ich jetzt mit Hilfe eines Kollegen hinbekommen...


```
public class Liste<T> {
	private Liste<T> nextReference;
	private Liste<T> root;
	private T data;
	
	public Liste(){}
	
	private Liste(T obj){
		data = obj;
	}
	public Liste<T> getNextReference(){
		return nextReference;
	}
	public T getData(){
		return data;
	}
	public void setNextReference(Liste<T> nr){
		this.nextReference = nr;
	}
	public void add(T obj){
		Liste<T> newElement = new Liste<T>(obj);
		if (root == null){
			root = newElement;
			nextReference = null;
		}
		else{
			Liste<T> lastElement = root;
			while (lastElement.getNextReference() != null)
				lastElement = lastElement.getNextReference();
			lastElement.setNextReference(newElement);
		}
	}
	public void printAllElements(){
		Liste<T> nextElement = root;
		while (nextElement.getData() != null || nextElement.getNextReference() != null){
			System.out.println(nextElement.getData());
			if (nextElement.getNextReference() != null)
				nextElement = nextElement.getNextReference();
			else 
				break;
		}
	}
}
```

printAllElements() hab ich jetzt eher zur einfachen Testausgabe implementiert. Läuft soweit...
naja jetzt mal an eine next() Methode hinsetzen. weiß noch nicht ganz wie ich das iterieren soll. 

danke für die schnelle hilfe

grüße


----------

