LinkedList

【Java源码分析之LinkedList】http://blog.csdn.net/jzhf2012/article/details/8540543 
【深入Java集合学习系列：LinkedList的实现原理】http://tan4836128.iteye.com/blog/1717809 
 List list = Collections.synchronizedList(new LinkedList(...)); 
此类的 iterator 和 listIterator 方法返回的迭代器是快速失败 的：在迭代器创建之后，如果从结构上对列表进行修改，除非通过迭代器自身的 remove 或 add 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒将来不确定的时间任意发生不确 定行为的风险。 


注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何硬性保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该 仅用于检测程序错误。 




private transient Entry<E> header = new Entry<E>(null, null, null); 
这个成员变量是LinkedList的关键，它在链表中没有实际数据意义，是链表的标示（通俗一点就是链表的第一个无意义的元素），而且被修饰为 transient，标示着他不会被序列化。header也可以当做队列末尾的元素，因为是双向列表，所以header.next末尾元素后边的元素就成 了队首元素，header.previous就是队尾元素了，看一下它的添加方法 
public void addFirst(E paramE) {   
    addBefore(paramE, this.header.next);//队首   
}   
public void addLast(E paramE) {   
    addBefore(paramE, this.header);//队尾   
} 
以上两个方法都利用addBefore方法将元素添加到指定对象之前， 
 addFirst向队头加元素，将元素paramE添加到header.next-队首元素之前； 
 addLast向队尾加元素，将元素paramE添加到header之前； 




再看一下addBefore(E e,Entry<E> entry)函数： 
/***  
 * 要添加的元素：paramE  
 * 目标对象：paramEntry  
 */   
private Entry<E> addBefore(E paramE, Entry<E> paramEntry)   
{   
    //要添加的对象   
    Entry localEntry = new Entry(paramE, paramEntry, paramEntry.previous);   
    /***  
     * localEntry.previous = paramEntry.previous  
     * 目标对象的前一元素的后一元素（localEntry.previous.next）设置为要添加的对象  
     */   
    localEntry.previous.next = localEntry;   
    /***  
     * localEntry.next = paramEntry  
     * 目标对象的前一元素（localEntry.next.previous）设置为要添加的对象  
     */   
    localEntry.next.previous = localEntry;   
    this.size += 1;   
    this.modCount += 1;   
    return localEntry;   
}   
  
链表的基本特性是插入速度快，遍历速度慢，下面两个方法可以反映这个特点 
public int indexOf(Object paramObject) {   
    int i = 0;   
    Entry localEntry;   
    /***  
     * 遍历规则：从头到尾，序列呈升序状态  
     */   
    if (paramObject == null)   
        for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {   
            if (localEntry.element == null)   
                return i;   
            i++;   
        }   
    else {   
        for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {   
            if (paramObject.equals(localEntry.element))   
                return i;   
            i++;   
        }   
    }   
    return -1;   
}   
public int lastIndexOf(Object paramObject) {   
    int i = this.size;   
    Entry localEntry;   
    /***  
     * 遍历规则：从尾到头，序列呈降序状态  
     */   
    if (paramObject == null) {   
        for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {   
            i--;   
            if (localEntry.element == null)   
                return i;   
            }   
    }else {   
        for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {   
            i--;   
            if (paramObject.equals(localEntry.element))   
                return i;   
        }   
    }   
    return -1;   
}   
 值得注意的是，链表插入数据速度快的说法是相对的，在数据量很小的时候，ArrayList的插入速度不仅不比LinkedList慢，而且还快很多（本文不作介绍，读者可自行测试），只有当数据量达到一定量，这个特性才会体现出来，这需要开发者明确需求场景 
LinkedList的方法entry(int index)类似ArrayList的get(int index) 

/***  
 * 根据序号获取Entry对象  
 */   
private Entry<E> entry(int paramInt) {   
    if ((paramInt < 0) || (paramInt >= this.size)) {   
        throw new IndexOutOfBoundsException("Index: " + paramInt + ", Size: " + this.size);   
    }   
    Entry localEntry = this.header;   
    int i;   
    /***  
     * 二分法：目标序号小于Size的1/2，则从头到尾  
     *             如果大于Size的1/2，则从尾到头  
     */   
    if (paramInt < this.size >> 1) {   
        for (i = 0; i <= paramInt; i++)   
            localEntry = localEntry.next;   
    } else {   
        for (i = this.size; i > paramInt; i--)   
            localEntry = localEntry.previous;   
    }   
    return localEntry;   
}   
LinkedList还提供了降序迭代器，如下 
  
public Iterator<E> descendingIterator()   {   
        return new DescendingIterator(null);   
    }   
  
关于降序迭代的具体实现可以看看源码，很简单 
LinkedList是针对链表操作的一个比较全的实现，对于频繁的数据插入有较高效率，研究其具体实现可更有利于准确的使用它。该类的toArray、clone以及其他一些方法很值得参考。 
  
3. LinkedList.Entry 
LinkedList的 内部类Entry是实现Deque接口的基本操作单元，其结构如下： 
  
Java代码  收藏代码 
private static class Entry<E>   
{   
    E element;   
    Entry<E> next;   
    Entry<E> previous;   
    /***  
     * 构造方法：目标对象paramE将被放置在paramEntry1之前，paramEntry2之后  
     */   
    Entry(E paramE, Entry<E> paramEntry1, Entry<E> paramEntry2)   
    {   
        this.element = paramE;   
        this.next = paramEntry1;   
        this.previous = paramEntry2;   
    }   
}   
  
  
4. 内部迭代器：ListItr 
  
虽然上层父类AbstractList<E>已经实现了迭代器，但LinkedList的直接父类AbstractSequentialList<E>给子类重新定义个一个需要实现的迭代器的抽象方法，代码如下： 
  
Java代码  收藏代码 
public abstract class AbstractSequentialList<E> extends AbstractList<E> {   
    /***  
     * 返回子类实现的迭代器  
     */   
    public Iterator<E> iterator() {   
        return listIterator();   
    }   
    public abstract ListIterator<E> listIterator(int paramInt);   
}   
  
此处实现的迭代器内部机制跟AbstractList基本一致，可以看看源码 
此类的迭代器的实现机制可以通过ListItr的remove方法来分析，同时也可分析Java对双端队列的处理办法 
  
Java代码  收藏代码 
/***  
 * 当前指针位置：this.next  
 * 当前所操作的对象：this.lastReturned  
 */   
public void remove() {   
    checkForComodification();   
    LinkedList.Entry localEntry = this.lastReturned.next;   
    try {   
        LinkedList.this.remove(this.lastReturned);   
    } catch (NoSuchElementException localNoSuchElementException) {   
        throw new IllegalStateException();   
    }   
    /***  
     * 当链表的size为0，指针会指向this.header，其他方法（如set方法）将以此判断当前操作对象的状态  
     */   
    if (this.next == this.lastReturned)   
        this.next = localEntry;   
    else   
        this.nextIndex -= 1;   
    /***  
     * 调用LinkedList.this.remove(E)之后  
     * 当前操作对象this.lastReturned指向的对象被设置为this.header（原对象为null）  
     * 指针移动到this.lastReturned.next  
     */   
    this.lastReturned = LinkedList.this.header;   
    //修改次数加1   
    this.expectedModCount += 1;   
}