LinkList的实现

 public class MyLinkedList<AnyType> implements Iterable<AnyType> {
     @Override
     public Iterator<AnyType> iterator() {
         return new LinkedListIterator();
     }

     public class LinkedListIterator implements Iterator<AnyType>{

         private Node current = beginMarker.next;
         private int expectedModCount = modCount;
         private int okToRemove = 0;

         @Override
         public boolean hasNext() {
             return current != endMarker;
         }

         @Override
         public AnyType next() {
             if(modCount != expectedModCount)
                 throw new ConcurrentModificationException();
             if(!hasNext())
                 throw new NoSuchElementException();

             AnyType element =  (AnyType)current.data;
             current = current.next;
             okToRemove++;
             return element;
         }

         public void remove(){
             if(modCount != expectedModCount)
                 throw new  ConcurrentModificationException();
             if(okToRemove>0)
                 throw new IllegalStateException();

             MyLinkedList.this.remove(current.prev);
             okToRemove--;
             expectedModCount++;
         }
     }

     private static class Node<AnyType>{
         public Node(AnyType d, Node<AnyType> p , Node<AnyType> n){
             data = d; prev = p; next = n;
         }
         public AnyType data;
         public Node<AnyType> prev;
         public Node<AnyType> next;
     }

     private int theSize;
     private int modCount = 0;
     private Node<AnyType> beginMarker;
     private Node<AnyType> endMarker;

     public void clear(){
         beginMarker = new Node<>(null,null,null);//endMarker还没有定义,因此还不能作为参数传入
         endMarker = new Node<>(null,beginMarker,null);
         beginMarker.next = endMarker;

         theSize = 0;
         modCount++;
     }

     public int size(){
         return theSize;
     }

     public boolean isEmpty(){
             return (size() == 0);
     }

     public Node<AnyType> getNode(int idx){
         if(idx < 0 || idx >= theSize)
             throw new IndexOutOfBoundsException();
         Node<AnyType> thisNode;
         if(idx < size()/2){
             thisNode = beginMarker.next;
             for(int i = 0; i < idx; i++)
                 thisNode = thisNode.next;
         }
         else {
             thisNode = endMarker.prev;
             for(int i = size(); i > idx; i--)
                 thisNode = thisNode.prev;
         }
         return thisNode;
     }

     public void add(int idx,AnyType element){
         addBefore(idx,element);
     }

     public void addBefore(int idx, AnyType element){
         if(idx < 0 || idx > size()){ //可取的最大值是最后一个的下一个
             throw new IndexOutOfBoundsException();
         }
         Node p = getNode(idx);
         Node current = new Node(element,p.prev,p);
         p.prev.next = current;
         p.prev = current;
         theSize++;
         modCount++;
     }

     public boolean add(AnyType element){
         add(theSize,element);
         return true;
     }

     public AnyType set(int idx, AnyType element){
         Node p = getNode(idx);
         AnyType oldVal = (AnyType) p.data;
         p.data = element;
         return oldVal;
     }

     public AnyType remove(int idx){
         return remove(getNode(idx));
     }

     public AnyType remove(Node p){
         p.prev.next = p.next;
         p.next.prev = p.prev;
         theSize--;
         modCount++;
         return (AnyType)p.data;
     }
 }

在链表和其迭代器中都定义modCount来标记当前操作数,是为了防止在两个类的对象中任意一个操作数据时,其他线程将链表改变,
如果modCount不匹配,则说明问题暴漏,即"快速失败".
okToRemove是为了防止删除头结点而设计.