java 链表实现 iterator iterable

import java.util.Iterator;

public interface ListInterface<T>{
	public boolean add(T newEntry);

	public boolean add(int newPosition, T newEntry);

	public T remove(int givenPosition);

	public void clear();

	public T set(int givenPosition, T newEntry);

	public T get(int givenPosition);

	public boolean contains(T anEntry);

	public int size();

	public boolean isEmpty();

	public boolean isFull();

	public void display();
}

import java.util.Iterator;


public interface ListWithIterator<T> extends ListInterface<T>,Iterable<T> {
	public Iterator<T> getIterator();
	public Iterator<T> iterator();
}

import java.security.NoSuchAlgorithmException;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class Llist<T> implements ListWithIterator<T> {
	private Node firstNode;
	private int length;

	private class Node {
		private T data;
		private Node next;

		Node(T dataPortion) {
			data = dataPortion;
			next = null;

		}

		Node(T dataPortion, Node nextNode) {
			data = dataPortion;
			next = nextNode;
		}

		public T getData() {
			return data;
		}

		public void setData(T data) {
			this.data = data;
		}

		public Node getNext() {
			return next;
		}

		public void setNext(Node next) {
			this.next = next;
		}

	}

	public Llist() {
		clear();
	}

	public Node getNodeAt(int givenPosition) {
		Node currentNode = firstNode;
		if (!isEmpty() && givenPosition >= 0 && givenPosition < length) {
			for (int i = 0; i < givenPosition; i++) {
				currentNode = currentNode.getNext();
			}
		} else {
			currentNode = null;
		}
		return currentNode;
	}

	@Override
	public boolean add(T newEntry) {
		// TODO Auto-generated method stub
		Node newNode = new Node(newEntry);
		if (isEmpty()) {
			firstNode = newNode;
		} else {
			Node lastNode = getNodeAt(length - 1);
			lastNode.setNext(newNode);

		}
		length++;
		System.out.println("add : " + newEntry);
		return true;
	}

	@Override
	public boolean add(int newPosition, T newEntry) {
		// TODO Auto-generated method stub
		boolean isAdd = true;

		if (newPosition >= 0 && newPosition <= length) {
			Node newNode = new Node(newEntry);
			if (isEmpty() || newPosition == 0) {
				newNode.setNext(firstNode);
				firstNode = newNode;
			} else {
				Node before = getNodeAt(newPosition - 1);
				Node after = before.getNext();
				newNode.setNext(after);
				before.setNext(newNode);
			}
			length++;
		} else
			isAdd = false;
		return isAdd;
	}

	@Override
	public T remove(int givenPosition) {
		// TODO Auto-generated method stub
		T result = null;
		if (!isEmpty() && givenPosition >= 0 && givenPosition < length) {
			if (givenPosition == 0) {
				result = firstNode.getData();
				firstNode = firstNode.getNext();
			} else {
				Node before = getNodeAt(givenPosition - 1);
				Node remove = before.getNext();
				Node after = remove.getNext();
				before.setNext(after);
				result = remove.getData();
			}
			length--;
		} else {
			System.out.println("删除出错");
		}
		return result;
	}

	@Override
	public final void clear() {
		// TODO Auto-generated method stub
		firstNode = null;

		length = 0;
	}

	@Override
	public T set(int givenPosition, T newEntry) {
		// TODO Auto-generated method stub
		T old = null;
		if (!isEmpty() && givenPosition >= 0 && givenPosition < length) {
			Node oldNode = getNodeAt(givenPosition);
			old = oldNode.getData();
			oldNode.setData(newEntry);
		} else {
			System.out.println("设置出错");
		}
		return old;
	}

	@Override
	public T get(int givenPosition) {
		// TODO Auto-generated method stub
		T result = null;
		if (!isEmpty() && givenPosition >= 0 && givenPosition < length)
			result = getNodeAt(givenPosition).getData();
		return result;
	}

	@Override
	public boolean contains(T anEntry) {
		// TODO Auto-generated method stub
		boolean isContain = false;
		Node currentnNode = firstNode;
		while (!isContain && currentnNode != null) {
			if (anEntry.equals(currentnNode.getData())) {
				isContain = true;
				System.out.println("包含该元素");
			} else {
				currentnNode = currentnNode.getNext();

			}

		}
		if (isContain == false)
			System.out.println("不包含该元素");
		return isContain;
	}

	@Override
	public int size() {
		// TODO Auto-generated method stub
		System.out.println("size :  " + length);
		return length;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		boolean result;
		if (length == 0 && firstNode == null) {
			result = true;
		} else {
			result = false;
		}
		return result;
	}

	@Override
	public boolean isFull() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void display() {

		// TODO Auto-generated method stub
		Node currentNode = firstNode;
		System.out.print("The list : ");
		while (currentNode != null) {
			System.out.print(currentNode.getData() + "  ");
			currentNode = currentNode.getNext();
		}
		System.out.println();
	}

	public Iterator<T> getIterator() {
		return new IteratorForLlist();
	}

	private class IteratorForLlist implements Iterator<T> {
		private Node nextNode;
		private boolean nextCalled;
		private int nextIndex;

		private IteratorForLlist() {
            nextIndex=0;
			nextNode=firstNode;
			nextCalled=false;
		}

		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			return nextNode!=null;
		}

		@Override
		public T next() {
			// TODO Auto-generated method stub
			if(hasNext())
			{
				nextCalled=true;
				Node returnNode=nextNode;
				nextNode=nextNode.next;
				nextIndex++;
				return returnNode.getData();
			}
			else {
				throw new NoSuchElementException( "iterator is after the end of list");
			}
		}

		@Override
		public void remove() {
			if(nextCalled)
			{
				Llist.this.remove(--nextIndex);
				nextCalled=false;
			}
			else {
				throw new UnsupportedOperationException(" can not remove");
			}
			// TODO Auto-generated method stub
			
		}
	}
	@Override
	public Iterator<T> iterator() {
		return getIterator();
	}
	/**
	 * @param argv
	 */
	public static void main(String[] argv) {
		Llist<Integer> list = new Llist<Integer>();
		list.display();
		list.add(5);
		list.add(6);
		list.add(1);
		list.add(2);
		list.add(3);
		list.size();
		list.display();
		Iterator<Integer> iterator=list.getIterator();
		for(Integer num:list)
			System.out.print(num + " "  );
		System.out.println();
		int i=0;
	    while(iterator.hasNext())
	    {
	    
	    	System.out.println(iterator.next());
	    	if(i==2)
	    		iterator.remove();
	    	i++;
	    }
	    list.display();
	}


}

Node，IteratorForList为内部类