Java LinkedList实现

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

public class MyLinkedList<AnyType> implements Iterable<AnyType> {
	
	private int theSize;
	//检测使用迭代器时合集是否改变
	private int modCount = 0;
	//存入始节点与尾节点方便插入第一个元素与末尾元素
	private Node<AnyType> beginMaker;
	private Node<AnyType> endMaker;

	public int size() {
		return theSize;
	}
	
	public boolean add(AnyType newVal) {
		addBefore(endMaker, newVal);
		return true;
	}
	
	public void add(int i, AnyType newVal) {
		addBefore(getNode(i), newVal);
	}
	
	public AnyType get(int i) {
		return getNode(i).data;
	}
	
	public AnyType set(int i, AnyType newVal) {
		Node<AnyType> p = getNode(i);
		AnyType oldVal = p.data;
		p.data = newVal;
		return oldVal;
	}
	
	public AnyType remove(int i) {
		return remove(getNode(i));
	}
	
	@Override
	public Iterator<AnyType> iterator() {
		return new LinkedIterator();
	}
	
	//无参构造
	public MyLinkedList() {
		doClear();
	}
	
	//内部类迭代器
	private class LinkedIterator implements Iterator<AnyType>{
		private Node<AnyType> current = beginMaker.next;
		//当expectedModCount与modCount不相等时，说明合集改变，迭代器失效
		private int expectedModCount = modCount;
		private boolean okToRemove = false;
		@Override
		public boolean hasNext() {
			return endMaker != current;
		}

		@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;
		}

	}
	
	//嵌套结点类
	private static class Node<AnyType> {
		public AnyType data;
		public Node<AnyType> prev;
		public Node<AnyType> next;
		//仅有参构造
		public Node(AnyType data, Node<AnyType> prev, Node<AnyType> next){
			this.data = data;
			this.prev = prev;
			this.next = next;
		}
	}
	
	private void addBefore(Node<AnyType> p, AnyType x) {
		Node<AnyType> newNode = new Node<>(x, p.prev, p);
		newNode.prev.next = newNode;
		p.prev = newNode;
		theSize++;
		modCount++;
	}
	
	private AnyType remove(Node<AnyType> p) {
		p.prev.next = p.next;
		p.next.prev = p.prev;
		theSize--;
		modCount++;
		
		return p.data;
	}
	
	private Node<AnyType> getNode(int i){
		return getNode(i, 0, theSize - 1);
	}
	
	private Node<AnyType> getNode(int i, int lower, int upper){
		Node<AnyType> p;
		if(i < lower || i > upper)
			throw new IndexOutOfBoundsException();
		if(i < size()/2) {
			p = beginMaker.next;
			for(int j = 0; j < i; j++) {
				p = p.next;
			}
		}
		else {
			p = endMaker.prev;
			for(int j = theSize; j > i; j--) {
				p = p.prev;
			}
		}
		return p;
	}
	
	private void doClear() {
		beginMaker = new Node<AnyType>(null, null, endMaker);
		endMaker = new Node<AnyType>(null, beginMaker, null);
		
		theSize = 0;
		modCount++;
	}
}

使用嵌套节点类，内部类实现迭代器