LinkedList类的自己实现和内容总结

package dataStructures.list;

public class AnyType {

}

package dataStructures.list;

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

public class MyLinkedList 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() {
		doClear();
	}
	//重新初始化一个空链表，包含头节点和尾节点，头节点的后继指向尾节点，尾节点的前驱指向头节点
	public 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 0==size();

	}
	
	public boolean add(AnyType x) {
		add(size(),x);
		return true;
	}
	
	public void add(int idx,AnyType x) {
		addBefore(getNode(idx), 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 idx) {
		return remove(getNode(idx));
	}
	/**在节点p的位置添加一个新的数据x
	 * 
	 * @param p 位置/节点
	 * @param x	新数据
	 */
	public void addBefore(Node<AnyType> p,AnyType x) {
		//创建一个新节点newNode,新节点的数据为x，前驱为p节点的前驱（p.pre），后继为p节点
		Node<AnyType>  newNode =new Node<>(x,p.prev,p);
		//新节点前驱的后继为新节点
		newNode.prev.next=newNode;
		//p节点的前驱为新节点
		p.prev=newNode;
		theSize++;
		modCount++;
	}
	
	/**
	 * 获取节点信息
	 */
	private Node<AnyType> getNode(int idx){
		return getNode(idx,0,size());//这里注意size()不能减一执行
	}
	/**
	 * 在idx位置上获取node信息
	 * 如果idx的位置在前半部分，则从头开始遍历，依次拿到当前节点的后继（next），直到获取idx的值
	 * 如果idx的位置在后半部分，则从末尾开始遍历，依次拿到当前节点的前驱（pre），直到获取idx的值
	 * @param idx
	 * @param lower
	 * @param uper
	 * @return
	 */
	private Node<AnyType> getNode(int idx,int lower,int uper){
		if (idx<lower || idx>uper) {
			throw new  IndexOutOfBoundsException();
		}
		Node<AnyType>  p;
		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;
	}
	/**
	 * 删除节点p
	 * 具体实现：p节点的下一个节点的前驱指向p节点的前驱，p节点的前一个节点的后继指向p节点的后继，
	 * 这样p节点在链表中就不存在了，等待垃圾回收
	 * @param p
	 * @return
	 */
	private AnyType remove(Node<AnyType> p) {
		p.next.prev=p.prev;
		p.prev.next=p.next;
		theSize--;
		modCount++;
		return p.data;
	}
	
	@Override
	public Iterator<AnyType> iterator() {
		return new LinkedListIterator();
	}
	
	private class LinkedListIterator implements Iterator<AnyType>{
		private Node<AnyType> current=beginMarker.next;
		private int expectedModCount=modCount;
		private boolean okToRemove=false;
		@Override
		public boolean hasNext() {
			return current!=endMarker;
		}
		
		/**
		 * 获取下一个节点的值
		 * 先获取头节点的下一个节点的data，再跳转到下一个节点，下次获取的就是跳转后节点的值
		 */
		@Override
		public AnyType next() {
			if (modCount!=expectedModCount) {
				throw new ConcurrentModificationException();
			}
			if (!hasNext()) {
				throw new NoSuchElementException();
			}
			AnyType nextItem=current.data;
			current=current.next;
			okToRemove=true;
			return nextItem;
		}
		
		public void remove() {
			if (modCount!=expectedModCount) {
				throw new ConcurrentModificationException();
			}
			if (!okToRemove) {
				throw new IllegalStateException();
			}
			MyLinkedList.this.remove(current.prev);
			expectedModCount++;
			okToRemove=false;
			
		}
		
	}
	
	public static void main(String[] args) {
		MyLinkedList list=new MyLinkedList();
		System.out.println(list.isEmpty());
		AnyType anyType1=new AnyType();
		AnyType anyType2=new AnyType();
		AnyType anyType3=new AnyType();
		AnyType anyType4=new AnyType();
		AnyType anyType5=new AnyType();
		AnyType anyType6=new AnyType();
		list.add(anyType1);
		list.add(anyType2);
		list.add(anyType3);
		list.add(anyType4);
		list.add(anyType5);
		list.add(anyType6);
		System.out.println("list的长度为："+list.size());
		list.remove(3);
		System.out.println("list的长度为："+list.size());
		Iterator<AnyType> iterator=list.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		
	}
}