# Iterable für doppeltverkettete Liste Implementieren



## Papuerus (27. Mai 2011)

Hallo, wir haben die Aufgabe eine doppelt verkettete Liste zu machen
die habe ich soweit hinbekommen
jetzt brauch ich aber noch einen Iterator und muss das über Iterable implementieren
z.B. für eine For each schleife

Ich weiß aber nicht wie man das genau macht
Also uns wurde gesagt wir brauchen dazu eine eigene neue Iterator Klasse usw
aber ich weiß nicht wie das aussehn muss -.-


Hier mein bis jetziger Code, ohne Iterable Implementierung

```
package lists.doublechained;


import java.util.Iterator;

import lists.ListElem;

/**
 * 
 */
public class LinkedList<T extends Comparable<T>> implements Iterable<T>
{
	/**
	 * Head element of the list
	 */
	private ListElem<T> head;
	
	/**
	 * Tail/Last element of the list
	 */
	private ListElem<T> tail;

	/**
	 * Number of entries stored in the list
	 */
	public int size;
	
	public LinkedList() {
		this.head = null;
		this.tail = null;
		this.size = 0;
	}

	/**
	 * adds a new element to the list's head
	 * 
	 * @param data
	 *            the content to add
	 */
	public void addFirst(T data) {
		
		ListElem<T> newElem = new ListElem<T>();
		newElem.data = data;
		newElem.next = head;
		head = newElem;
		size++;
		
	}

	/**
	 * adds a new element to the list's tail
	 * 
	 * @param data
	 *            the content to add
	 */
	public void addLast(T data) {
		
		ListElem<T> newElem = new ListElem<T>();
		newElem.data = data;
		newElem.prev = tail;
		tail = newElem;
		size++;
	}

	/**
	 * returns the element located at the given position
	 * 
	 * @param index
	 *            the given position
	 * @return the element contained at the given position or null if given
	 *         index does not exist.
	 */
	public T get(int index) {
		if (index >= size || index < 0) {
			return null;
		} else {
			ListElem<T> current = head;
			while (index-- > 0) {
				current = current.next;
			}
			return current.data;
		}
	}

	/**
	 * removes and returns the first element of the list
	 * 
	 * @return the first element if one exists, null otherwise
	 */
	public T removeFirst() {
		T result = null;
		
		if(size < 2){
			result = null;
		}
		else
		{
			result = head.data;
			head = head.next;
			size--;
		}
		return result;
	}

	/**
	 * removes and returns the last element of the list
	 * 
	 * @return the last element if one exists, null otherwise
	 */
	public T removeLast() {
		T result = null;
		
		if(size < 2){
			result = null;
		}
		else
		{
			result = tail.data;
			tail = tail.prev;
			size--;
		}
		return result;
	}

	/**
	 * removes and returns the element located at the given position
	 * 
	 * @param index
	 *            the given position
	 * @return the element contained at the given position or null if given
	 *         index does not exist.
	 */
	public T remove(int index) {
		T result = null;
		
		if(index < 0 || index >= size){
			result = null;
		}else{
			if(index == 0){
				result = head.data;
				head = head.next;
				size--;
			}else{
				ListElem<T> current = head;
				while(index-- > 1){
					current = current.next;
				}
				result = current.next.data;
				current.next = current.next.next;
				size--;
			}
		}
		
		return result;
	}

	/**
	 * @return whether this list is empty or not
	 */
	public boolean isEmpty() {
		return this.size == 0;
	}

	/**
	 * @return the list's size
	 */
	public int size() {
		return this.size;
	}

}
```


----------



## Papuerus (27. Mai 2011)

So schaut im Übrigen ListElem aus:


```
package lists;
/**
 *
 */
public class ListElem<T extends Comparable<T>> implements Comparable<ListElem<T>>{

   public T data;
   public ListElem<T> prev;
   public ListElem<T> next;
   
	/**
	 * Empty constructor, initializes data and next with null
	 */
   public  ListElem(){
       this.data = null;
       this.prev = null;
       this.next = null;
   }

	@Override
	public int compareTo(ListElem<T> other) {
		return this.data.compareTo(other.data);	
	}
	
}
```


----------



## SlaterB (27. Mai 2011)

was ist denn ein Iterator, schau dir doch mal dieses Interface an, erstelle eine Klasse mit Dummy-Implementierung (leere Methoden oder return null)
dann überlege nach und nach was in jede Methode reingehört bzw. stelle intelligentere Fragen als nur
'ich mache gar nichts, ihr bitte jetzt machen'

'java iterator example' darf auch in Suchmaschinen eingetippt werden


----------



## Papuerus (27. Mai 2011)

So sollte es nicht rüber kommen sry, wie gesagt das Prinzip ist mir (irgendwie) wieder klar und ich will auch keine fertige Implementierung, sondern eher wissen, muss ich jetzt in meiner Listenklasse wirklich nur Iterable implementieren und diesen dann geforderten Iterator über eine eigene Klasse definieren, die dann wiederum Iterator implementieren muss, oder kann ich auch Iterable und Iterator in meiner Listenklasse zusammen implemenieren?

Edit:
Der Unterschied zwischen Iterabele und Iterator kam in unserem Tutorium leider zu kurz, deswegen weiß ich auch nicht wie man damit genau umgeht...


----------



## SlaterB (27. Mai 2011)

> Der Unterschied zwischen Iterabele und Iterator kam in unserem Tutorium leider zu kurz

wenn du hier im Internet nachfragst musst du auch damit leben, dass du hier im Internet überall alles erstmal in Lehrbüchern nachlesen kannst 
daher ist das keine Ausrede, gibt genug kostenlose Bücher und Tutorials, etwa
Galileo Computing :: Java ist auch eine Insel – 13.2 Mit einem Iterator durch die Daten wandern

ich antworte mal so als wenn du das mehr oder weniger verstanden hättest, was dann eigentlich auch diese Antworten fast obsolet macht:
die Liste soll Iterable sein, deswegen wird diese das Interface implementieren, ja

sie muss dann Iterator-Objekte zurückgeben, diese sollten eine eigene Klasse sein, es bringt nichts das zu mischen, schon gar nicht etwa das Listen-Objekt selber in der Rolle eines Iterators zurückzugeben, weil nach dem Konzept gleichzeitig mehrere Iteratoren mit eigenen Verarbeitungsstand bestehen können sollten


----------



## Papuerus (27. Mai 2011)

Danke, ich werde es mir genau anschauen


----------



## Papuerus (27. Mai 2011)

folgendes Problem

ich brauch doch jetzt in der Klasse "MyIterator"
eine LinkedListe, weil ich die ja irgendwie aus der Klasse LinkedListe übergeben muss, damit ich da durchzählen kann, aber


```
privat LinkedList<T> arr = null;
```
geht nicht, wie mach ich es denn dann?


----------



## SlaterB (28. Mai 2011)

Parameter im Konstruktur, die Liste erzeugt einen Iterator etwa mit new MyIterator(this);


----------

