LinkedList,双向链表的实现

通过三个类来实现

1、LinkedList类本身

2、Node类，这个类是list的元素-节点，list用它来存储每一个元素，这个类包含三个成员变量：data(该节点值)、prev(对前一个节点的引用)、next(对后一个节点的引用)

3、迭代器LinkedListIterator类，该类实现Iterator接口，提供next()/hasNext/remove的实现

如下是原理图，包含一个头节点和尾节点，头节点的data为空，指向前一个节点的引用为空，只有指向后一个节点的引用，尾节点同理。

说再多概念也不好理解，直接看代码，代码里我都写了注释，看懂代码就懂了

import java.util.ConcurrentModificationException;
import java.util.Iterator;

/**
 * @description   
 * @author Zhangx
 * @date 2015年12月2日 下午3:59:54
 * @version 1.0 
 */
public class MylinkedList implements Iterable{
	
	private int theSize;                 //当前元素个数
	private int modCount = 0;            //对list的写操作次数
	private Node beginMarker;   //头节点
	private Node endMarker;     //尾节点
	
	/**
	 * 初始化list,调用clear()
	 */
	public MylinkedList(){
		clear();
	}
	
	/**
	 * 将list元素个数设置为0，设置头节点和尾节点，操作次数+1
	 */
	public void clear() {
		theSize = 0;
		
		beginMarker = new Node(null, null, null);
		endMarker = new Node(null, beginMarker, null);
		beginMarker.next = endMarker;
		
		modCount++;
	}
	
	/**
	 * list元素个数
	 * @return int
	 */
	public int size(){
		return theSize;
	}
	
	/**
	 * list是否为空
	 * @return boolean
	 */
	public boolean isEmpty(){
		return size()==0;
	}
	
	/**
	 * 添加元素
	 * @param x
	 * @return boolean
	 */
	public boolean add(AnyType x){
		add(size(), x);
		return true;
	}
	
	/**
	 * 在idx位置处添加元素
	 * @param idx
	 * @param newVal
	 */
	public void add(int idx, AnyType newVal){
		addBefore(getNode(idx), newVal);
	}
	
	/**
	 * 获得idx位置处节点的data值
	 * @param idx
	 * @return AnyType
	 */
	public AnyType get(int idx){
		return getNode(idx).data;
	}
	
	/**
	 * 将指定位置处的节点的data值设为新值
	 * @param idx
	 * @param newVal
	 * @return
	 */
	public AnyType set(int idx, AnyType newVal){
		Node p = getNode(idx);
		
		AnyType old = p.data;
		p.data = newVal;
		
		return old;
	}
	
	/**
	 * 删除元素
	 * @param idx
	 * @return AnyType
	 */
	public AnyType remove(int idx){
		return remove(getNode(idx));
	}
	
	/**
	 * 在指定节点之前位置插入一个新节点
	 * @param p
	 * @param x
	 */
	private void addBefore(Node p, AnyType x){
		
		Node node = new Node(x, p.prev, p);     //获得一个前节点为P的前节点，后节点为p，data为x的新节点
		p.prev.next = node;                              //将p的前节点的后节点设为新节点node
		p.prev = node;                                   //将p的前节点设为新节点node
		
		theSize++;
		modCount++;
	}
	
	/**
	 * 删除指定节点
	 * @param p
	 * @return
	 */
	private AnyType remove(Node p){
		p.next.prev = p.prev;                  //将当前节点的后一个节点对前一个节点的引用设为当前节点的前一个节点
		p.prev.next = p.next;                  //将当前节点的前一个节点对后一个节点的引用设为当前节点的后一个节点
		
		theSize--;
		modCount++;
		
		return p.data;
	}
	
	/**
	 * 获得指定位置的节点
	 * @param idx
	 * @return
	 */
	private Node getNode(int idx){
		
		Node p;
		
		if(idx<0||idx>size()){
			throw new IndexOutOfBoundsException();
		}
		
		if(idxidx;i--){
				p = p.prev;
			}			
		}
		
		return p;
	}

	/**
	 * list实现的核心元素-节点，其实就是一个私有的泛型静态类，其中有三个元素，一个保存节点值，一个保存到前一个节点的引用，
	 * 一个保存到后一个节点的引用
	 * @author Zhangxin
	 *
	 * @param 
	 */
	private static class Node{
		
		public AnyType data;
		public Node prev;
		public Node next;
		
		public Node(AnyType d, Node p, Node n){
			data = d;
			prev = p;
			next = n;
		}
	}
	
	@Override
	public Iterator iterator() {
		return new LinkedListIterator();
	}
	
	/**
	 * 迭代器
	 * @author Zhangxin
	 *
	 */
	private class LinkedListIterator implements Iterator{
		
		private Node current = beginMarker.next;
		private int expectedModCount = modCount;
		private boolean okToRemove = false;
		
		@Override
		public boolean hasNext() {
			return current!=endMarker;
		}

		@Override
		public AnyType next() {
			
			if(modCount!=expectedModCount){
				throw new ConcurrentModificationException();
			}else if(!hasNext()){
				throw new IndexOutOfBoundsException();
			}
			
			AnyType data = current.data;
			current = current.next;
			okToRemove = true;
			
			return data;
			
		}

		@Override
		public void remove() {
			
			if(modCount!=expectedModCount){
				throw new ConcurrentModificationException();
			}else if(!hasNext()){
				throw new IndexOutOfBoundsException();
			}
			
			MylinkedList.this.remove(current.prev);
			okToRemove = false;
			expectedModCount++;
		}
	}

}