手动编写LinkedList类

import java.util.Iterator;


public class MyLinkedList<AnyType> implements Iterable<AnyType>{
	private static class Node<AnyType>
	{
		public AnyType data;
		public Node<AnyType> prev;
		public Node<AnyType> next;
		public Node(AnyType d,Node<AnyType> p,Node<AnyType> n){
			data = d;
			prev=p;
			next=n;
		}
	}
	
	private int theSize;
	private int modCount=0;//链表中对象的个数 初始时有两个 
	private Node<AnyType> beginMarker;
	private Node<AnyType> endMarker;
	public MyLinkedList(){//构造函数
		doClear();
	}
	
	public void clear(){//重置MyLinkedList
		doClear();
	}
	private void doClear(){//创建两个相互连接的节点
			beginMarker = new Node<AnyType>(null,null,null);
			endMarker = new Node<AnyType>(null,beginMarker,null);
			beginMarker.next=endMarker;
			theSize=0;
			modCount++;
	}
	
	
	
	public int size(){
		return theSize;
	}
	
	public boolean isEmpty(){
		return size()==0;
	}
	
	public boolean add(AnyType x){
		add(size(),x);
		return true;
	}
	public void add(int idx,AnyType x){
		addBefore(getNode(idx,0,size()),x);
	}
	public AnyType get(int idx){
		return getNode(idx).data;
	}
	public AnyType set(int idx,AnyType newVal){
		Node<AnyType> p = getNode(idx);
		AnyType oldVal = p.data;
		p.data = newVal;
		return oldVal;
	}
	
	public AnyType remove(int x){
		return remove(getNode(x));
	}
	//---------上代码皆有底层链表实现
	//底层链表
	//删除节点
	private AnyType remove(Node<AnyType> p){
		p.next.prev=p.prev;
		p.prev.next=p.next;
		theSize--;
		modCount++;
		return p.data;
	}
	
	
	
	
	
	//插入数据
	private void addBefore(Node<AnyType> p,AnyType x){//节点+数据 将一个数据插入另一个节点前面
		Node<AnyType> newNode = new Node<AnyType>(x,p.prev,p);//创建新的节点
		newNode.prev.next=newNode;
		p.prev=newNode;
		theSize++;
		modCount++;
	}
	private Node<AnyType> getNode(int idx){
		return getNode(idx,0,size()-1);
	}
	private Node<AnyType> getNode(int idx,int lower,int upper){
		Node<AnyType> p;
		//查找相应位置的节点并返回
		if(idx<lower||idx>upper){
			throw new IndexOutOfBoundsException();
		}
		if(idx<size()/2){
			p=beginMarker.next;
			for(int i=0;i<idx;i++){
				p=p.next;
			}
		}else
		{
			p=endMarker;
			for(int i=size();i>idx;i--){
				p=p.prev;
			}
		}
	return p;
	}
	
	
	public java.util.Iterator<AnyType> iterator(){
		return new LinkedListIterator();
	}
	
	private class LinkedListIterator implements java.util.Iterator<AnyType>
	{
		
		private Node<AnyType> current = beginMarker.next;
		private int expectedModCount = modCount;
		private boolean okToRemove = false;
		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			return current!=endMarker;//直接比较对象  方式不赞同
		}
		
		@Override
		public AnyType next() {
			// TODO Auto-generated method stub
			if(modCount != expectedModCount){
				throw new java.util.ConcurrentModificationException();
			}
			if(!hasNext()){
				throw new java.util.NoSuchElementException();
			}
			AnyType newxtItem = current.data;
			current=current.next;
			okToRemove=true;
			return newxtItem;
		}

		@Override
		public void remove() {
			if(modCount !=expectedModCount){
				throw new java.util.ConcurrentModificationException();
			}
			if(!okToRemove){//这个位置删除过后无法删除
				throw new IllegalAccessError();
			}
			MyLinkedList.this.remove(current.prev);
			expectedModCount++;
			okToRemove = false;//不能在一个位置一直删除
			// TODO Auto-generated method stub
			
		}
		
	}


	




	
	
}