Java源码阅读之LinkedList<E>

类定义

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>,Deque<E>,Cloneabl,java.io.Serializable{}
// 从类定义中可以看出LinkedList是一个有序的list集合，并且可以看做是一个栈或者队列

构造函数

节点内部类

private static class Node<E>{
	//每个节点存储的元素
	E item;
	// 下一个节点
	Node<E> next;
	// 上一个节点
	Node<E> prev;
	
	// 构造函数
	Node<E>(Node<E> prev, E element, Node<E> next){
		this.prev = prev;
		this.item = element;
		this.next = next;
	}
}

方法

void linkFirst(E e){
	final Node<E> f = first;
	final Node<E> newNode = new Node(null, e, f);
	first = newNode;
	if(f == null){
		last = newNode;
	}else{
		f.prev = newNode;
	}
	size++;
	modCount++;
}

void linkLast(E e){
	final Node<E> l = last;
	final Node<E> newNode = new Node(l, e, null);
	last = newNode;
	if(l == null){
		first = newNode;
	}else{
		l.next = newNode;
	}
	size++;
	modCount++;
}

// 在指定节点之前连接节点，要求succ不能为空
void linkBefore(E e, Node<E> succ){
	final Node<E> pred = succ.prev;
	final Node<E> newNode = new Node(pred, e, succ);
	succ.prev = newNode;
	if(pred == null){
		first = newNode;
	}else{
		pred.next = newNode;
	}
	size++;
	modCount++;
}

// 移除对头元素，并返回值，要求f不能为空
private E unlinkFirst(Node<E> f){
	final E element = f.item;
	final Node<E> next = f.next;
	f.item = null;
	f = null;
	first = next;
	if(next == null){
		last = null;
	}else{
		next.prev = null;
	}
	size--;
	modCount++;
	return element;
}

// 移除队尾元素，并返回值，要求l不能为null
private E unlinkLast(Node<E> l){
	final E element = l.item;
	final Node<E> prev = l.prev;
	l.item = null;
	l = null;
	last = prev;
	if(prev == null){
		first = null;
	}else{
		prev.next = null;
	}
	size --;
	modCount ++;
	return element;
}

// 移除不为空的x节点，并返回值
E unLink(Node<E> x){
	final E element = x.item;
	final Node<E> prev = x.prev;
	final Node<E> next = x.next;
	if(prev == null){
		first = next;
	}else{
		prev.next = next;
	}
	if(next == null){
		last = prev;
	}else{
		next.prev = prev;
	}
	x.item = null;
	size --;
	modCount ++;
	return element;
}

// 返回对头元素的值，如果没有对头元素则抛出异常
// throws NoSuchElementException
public E getFirst(){
	final Node<E> f = first;
	if(f == null)
		throw new NoSuchElementException();
	return f.item;
}

public E getLast(){
	final Node<E> l = last;
	if(l == null)
		throw new NoSuchElementException();
	return l.item;
}

// 移除对头元素，并返回对头元素的值，如果队列为空则抛出异常
public E removeFirst(){
	final Node<E> f = first;
	if(f == null)
		throw new NoSuchElementException();
	return unlinkFirst(f);
}

public E removeLast(){
	final Node<E> l = last;
	if(l == null)
		throw new NoSuchElementException();
	return unlinkLast(l);
}

public void addFirst(E e){
	linkFirst(e);
}

// 移除队列中第一次出现的指定元素
// 移除成功则返回true，否则返回false
public boolean remove(Object o){
	if(o == null){
		for(Node<E> x = first; x != null; x=x.next){
			if(x.item == null){
				unlink(x);
				return true;
			}
		}
	}else{
		for(Node<E> x = first; x != null; x = x.next){
			if(o.equals(x.item)){
				unlink(x);
				return true;
			}
		}
	}
	return false;
}

// 将c中的所有元素添加到linklist的索引index处
public boolean addAll(Collection<? extends E> c, int index){
	// 验证index 是否合法
	checkPositionIndex(index);

	Object[] a = c.toArray();
	int newLength = c.length;
	if(newLength == 0)
		return false;
	Node<E> pred, succ;
	if(index == size){
		pred = last;
		succ = null;
	}else{
		succ = node(index);
		pred = succ.prev;
	}
	for(Object o : a){
		Node<E> newNode = new Node(pred, o, null);
		if(pred == null){
			first = newNode;
		}else{
			pred.next = newNode;
		}
		pred = newNode;
	}
	
	if(succ == null){
		last = pred;
	}else{
		pred.next = succ;
		succ.prev = pred;
	}
	size += newLength;
	modCount++;
	return true;
}

// 清空列表
public void clear(){
	for(Node<E> x = first; x != null;){
		Node<E> next = x.next;
		x.prev = null;
		x.item = null;
		x.pred = null;
		x = next;
	}
	first = last = null;
	size = 0;
	modCount ++;
}

// 返回指定索引处的节点
Node<E> node(int index){
	if(index < (size >> 1)){
		Node<E> x = first;
		for(int i = 0; i < index; i++){
			x = x.next;
		}
		return x;
	}else{
		Node<E> x = last;
		for(int i = size-1; i > index; i--){
			x = x.prev;
		}
		return x;
	}
}

// 返回指定元素第一次出现在list中的索引
// 如果不存在则返回-1
public int indexOf(Object o){
	int index = 0;
	if(o == null){
		for(Node<E> x = first; x != null; x=x.next){
			if(x.item == null){
				return index;
			}
			index++;
		}
	}else{
		for(Node<E> x = first; x != null; x = x.next){
			if(o.equals(x.item))
				return index;
			index++;
		}
	}
	return -1;
}

// 返回指定元素在列表中最后一次出现时的索引
// 如果不包含指定元素则返回-1
public int lastIndexOf(Object o){
	int index = size-1;
	if(o == null){
		for(Node<E> x = last; x != null; x = x.prev){
			if(x.item == null){
				return index;
			}
			index --;
		}
	}else{
		for(Node<E> x = last; x != null; x = x.prev){
			if(o.equals(x.item)){
				return index;
			}
			index --;
		}
	}
	return -1;
}

// 返回对头元素的值，如果队列为空，则返回null
public E peek(){
	final Node<E> f = first;
	return (f == null) ? null : f.item;
}

迭代器内部类

private class ListItr<E> extends ListIterator<E>{
	private Node<E> next;
	private Node<E> lastReturned;
	private int index;
	private int expectedModCount = modCount;

	ListItr(int index){
		this.next = (index == size) ? null : node(index);
		this.index = index;
	}
	
	public boolean hasNext(){
		return index < size;
	}

	public E next(){
		checkForComdification();
	
		if(!hasNext()){
			throw new NoSuchElementException();
		}
		lastReturned = next;
		index ++;
		next = next.next;
		return lastReturned.item;
	}
	
	public boolean hasPrevious(){
		return index > 0;
	}

	public E previous(){
		checkForComidification();
		if(!hasPrevious){
			throw new NoSuchElementException();
		}
		lastReturned = next = (next == null) ? last : next.prev;
		index --;
		return lastReturned.item;
	}
	
	public int nextIndex(){
		return index;
	}	
	
	public int previousIndex(){
		return index - 1;
	}
	
	public void remove(){
		checkForComdification();
		
		if(lastReturned == null){
			throw new IllegalStateException();
		}
		Node<E> lastNext = lastReturned.next;
		unlink(lastReturned);
		if(next == lastReturned){
			next = lastNext;
		}else{
			nextIndex--;
		}
		lastReturned = null;
		expectedModCount ++;
	}
	public void set(E e){
		checkComidification();
		if(lastReturned == null)
			throw new IllegalStateException();
		lastReturned.item = e;
	} 

	public void add(E e){
		checkForComodification();
		lastReturned = null;
		if(next == null){
			linkLast(e);
		}else{
			linkBefore(e, next);
		}
		index ++;
		expectedModCount ++;
	}
}

// 逆向单向的迭代器
private class DescendingIterator<E> extends Iterator<E>{
	private final ListItr itr = new ListItr(size());
	
	public boolean haxNext(){
		return itr.hasPrevious();
	}

	public E next(){
		return itr.previous();
	}

	public void remove(){
		itr.remove();
	}
}