Java 集合系列 04 LinkedList详细介绍(源码解析)和使用示例

java 集合系列目录：

Java 集合系列 01 总体框架

Java 集合系列 02 Collection架构

Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例

Java 集合系列 04 LinkedList详细介绍(源码解析)和使用示例

Java 集合系列 05 Vector详细介绍(源码解析)和使用示例

Java 集合系列 06 Stack详细介绍(源码解析)和使用示例

Java 集合系列 07 List总结(LinkedList, ArrayList等使用场景和性能分析)

Java 集合系列 08 Map架构

Java 集合系列 09 HashMap详细介绍(源码解析)和使用示例

Java 集合系列 10 Hashtable详细介绍(源码解析)和使用示例

Java 集合系列 11 hashmap 和 hashtable 的区别

Java 集合系列 12 TreeMap

Java 集合系列 13 WeakHashMap

Java 集合系列 14 hashCode

Java 集合系列 15 Map总结

Java 集合系列 16 HashSet

Java 集合系列 17 TreeSet

概要 

和学习ArrayList一样，接下来呢，我们先对LinkedList有个整体认识，然后再学习它的源码；最后再通过实例来学会使用LinkedList。内容包括：
第1部分 LinkedList介绍
第2部分 LinkedList数据结构
第3部分 LinkedList源码解析(基于JDK1.7)
第4部分 LinkedList遍历方式

第1部分 LinkedList介绍

LinkedList简介

LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList 实现 List 接口，能对它进行队列操作。
LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
LinkedList 是非同步的。

LinkedList构造函数

// 默认构造函数
LinkedList()

// 创建一个LinkedList，保护Collection中的全部元素。
LinkedList(Collection<? extends E> collection)

LinkedList的API

LinkedList的API
boolean       add(E object)
void          add(int location, E object)
boolean       addAll(Collection<? extends E> collection)
boolean       addAll(int location, Collection<? extends E> collection)
void          addFirst(E object)
void          addLast(E object)
void          clear()
Object        clone()
boolean       contains(Object object)
Iterator<E>   descendingIterator()
E             element()
E             get(int location)
E             getFirst()
E             getLast()
int           indexOf(Object object)
int           lastIndexOf(Object object)
ListIterator<E>     listIterator(int location)
boolean       offer(E o)
boolean       offerFirst(E e)
boolean       offerLast(E e)
E             peek()
E             peekFirst()
E             peekLast()
E             poll()
E             pollFirst()
E             pollLast()
E             pop()
void          push(E e)
E             remove()
E             remove(int location)
boolean       remove(Object object)
E             removeFirst()
boolean       removeFirstOccurrence(Object o)
E             removeLast()
boolean       removeLastOccurrence(Object o)
E             set(int location, E object)
int           size()
<T> T[]       toArray(T[] contents)
Object[]     toArray()

AbstractSequentialList简介

在介绍LinkedList的源码之前，先介绍一下AbstractSequentialList。毕竟，LinkedList是AbstractSequentialList的子类。

AbstractSequentialList 实现了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)这些函数。这些接口都是随机访问List的，LinkedList是双向链表；既然它继承于AbstractSequentialList，就相当于已经实现了“get(int index)这些接口”。

此外，我们若需要通过AbstractSequentialList自己实现一个列表，只需要扩展此类，并提供 listIterator() 和 size() 方法的实现即可。若要实现不可修改的列表，则需要实现列表迭代器的 hasNext、next、hasPrevious、previous 和 index 方法即可。

第2部分 LinkedList数据结构

LinkedList的继承关系

java.lang.Object
   ↳     java.util.AbstractCollection<E>
         ↳     java.util.AbstractList<E>
               ↳     java.util.AbstractSequentialList<E>
                     ↳     java.util.LinkedList<E>

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable {}

LinkedList与Collection关系如下图：

第3部分 LinkedList源码解析(基于JDK1.7)

为了更了解LinkedList的原理，下面对LinkedList源码代码作出分析。

在阅读源码之前，我们先对LinkedList的整体实现进行大致说明：
    LinkedList实际上是通过双向链表去实现的。既然是双向链表，那么它的顺序访问会非常高效，而随机访问效率比较低。
    既然LinkedList是通过双向链表的，但是它也实现了List接口{也就是说，它实现了get(int location)、remove(int location)等“根据索引值来获取、删除节点的函数”}。LinkedList是如何实现List的这些接口的，如何将“双向链表和索引值联系起来的”？
    实际原理非常简单，它就是通过一个计数索引值来实现的。例如，当我们调用get(int location)时，首先会比较“location”和“双向链表长度的1/2”；若前者大，则从链表头开始往后查找，直到location位置；否则，从链表末尾开始先前查找，直到location位置。
   这就是“双线链表和索引值联系起来”的方法。

好了，接下来开始阅读源码(只要理解双向链表，那么LinkedList的源码很容易理解的)。

有关LinkedList在JDK1.6和JDK1.7的区别以及优化，参看 JDK1.7-LinkedList循环链表优化，这里列出是1.7的源码

其中 Node：

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

 public class LinkedList<E>
     extends AbstractSequentialList<E>
     implements List<E>, Deque<E>, Cloneable, java.io.Serializable
 {
     transient int size = 0;

     /**
      * Pointer to first node.
      * Invariant: (first == null && last == null) ||
      *            (first.prev == null && first.item != null)
      */
     transient Node<E> first;

     /**
      * Pointer to last node.
      * Invariant: (first == null && last == null) ||
      *            (last.next == null && last.item != null)
      */
     transient Node<E> last;

     /**
      * Constructs an empty list.
      */
     public LinkedList() {
     }

     /**
      * Constructs a list containing the elements of the specified
      * collection, in the order they are returned by the collection's
      * iterator.
      *
      * @param  c the collection whose elements are to be placed into this list
      * @throws NullPointerException if the specified collection is null
      */
     public LinkedList(Collection<? extends E> c) {
         this();
         addAll(c);
     }

     /**
      * Links e as first element.
      */
     private 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++;
     }

     /**
      * Links e as last element.
      */
     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++;
     }

     /**
      * Inserts element e before non-null Node succ.
      */
     void linkBefore(E e, Node<E> succ) {
         // assert succ != null;
         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++;
     }

     /**
      * Unlinks non-null first node f.
      */
     private E unlinkFirst(Node<E> f) {
         // assert f == first && f != null;
         final E element = f.item;
         final Node<E> next = f.next;
         f.item = null;
         f.next = null; // help GC
         first = next;
         if (next == null)
             last = null;
         else
             next.prev = null;
         size--;
         modCount++;
         return element;
     }

     /**
      * Unlinks non-null last node l.
      */
     private E unlinkLast(Node<E> l) {
         // assert l == last && l != null;
         final E element = l.item;
         final Node<E> prev = l.prev;
         l.item = null;
         l.prev = null; // help GC
         last = prev;
         if (prev == null)
             first = null;
         else
             prev.next = null;
         size--;
         modCount++;
         return element;
     }

     /**
      * Unlinks non-null node x.
      */
     E unlink(Node<E> x) {
         // assert x != null;
         final E element = x.item;
         final Node<E> next = x.next;
         final Node<E> prev = x.prev;

         if (prev == null) {
             first = next;
         } else {
             prev.next = next;
             x.prev = null;
         }

         if (next == null) {
             last = prev;
         } else {
             next.prev = prev;
             x.next = null;
         }

         x.item = null;
         size--;
         modCount++;
         return element;
     }

     /**
      * Returns the first element in this list.
      *
      * @return the first element in this list
      * @throws NoSuchElementException if this list is empty
      */
     public E getFirst() {
         final Node<E> f = first;
         if (f == null)
             throw new NoSuchElementException();
         return f.item;
     }

     /**
      * Returns the last element in this list.
      *
      * @return the last element in this list
      * @throws NoSuchElementException if this list is empty
      */
     public E getLast() {
         final Node<E> l = last;
         if (l == null)
             throw new NoSuchElementException();
         return l.item;
     }

     /**
      * Removes and returns the first element from this list.
      *
      * @return the first element from this list
      * @throws NoSuchElementException if this list is empty
      */
     public E removeFirst() {
         final Node<E> f = first;
         if (f == null)
             throw new NoSuchElementException();
         return unlinkFirst(f);
     }

     /**
      * Removes and returns the last element from this list.
      *
      * @return the last element from this list
      * @throws NoSuchElementException if this list is empty
      */
     public E removeLast() {
         final Node<E> l = last;
         if (l == null)
             throw new NoSuchElementException();
         return unlinkLast(l);
     }

     /**
      * Inserts the specified element at the beginning of this list.
      *
      * @param e the element to add
      */
     public void addFirst(E e) {
         linkFirst(e);
     }

     /**
      * Appends the specified element to the end of this list.
      *
      * <p>This method is equivalent to {@link #add}.
      *
      * @param e the element to add
      */
     public void addLast(E e) {
         linkLast(e);
     }

     /**
      * Returns {@code true} if this list contains the specified element.
      * More formally, returns {@code true} if and only if this list contains
      * at least one element {@code e} such that
      * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
      *
      * @param o element whose presence in this list is to be tested
      * @return {@code true} if this list contains the specified element
      */
     public boolean contains(Object o) {
         return indexOf(o) != -1;
     }

     /**
      * Returns the number of elements in this list.
      *
      * @return the number of elements in this list
      */
     public int size() {
         return size;
     }

     /**
      * Appends the specified element to the end of this list.
      *
      * <p>This method is equivalent to {@link #addLast}.
      *
      * @param e element to be appended to this list
      * @return {@code true} (as specified by {@link Collection#add})
      */
     public boolean add(E e) {
         linkLast(e);
         return true;
     }

     /**
      * Removes the first occurrence of the specified element from this list,
      * if it is present.  If this list does not contain the element, it is
      * unchanged.  More formally, removes the element with the lowest index
      * {@code i} such that
      * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
      * (if such an element exists).  Returns {@code true} if this list
      * contained the specified element (or equivalently, if this list
      * changed as a result of the call).
      *
      * @param o element to be removed from this list, if present
      * @return {@code true} if this list contained the specified element
      */
     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;
     }

     /**
      * Appends all of the elements in the specified collection to the end of
      * this list, in the order that they are returned by the specified
      * collection's iterator.  The behavior of this operation is undefined if
      * the specified collection is modified while the operation is in
      * progress.  (Note that this will occur if the specified collection is
      * this list, and it's nonempty.)
      *
      * @param c collection containing elements to be added to this list
      * @return {@code true} if this list changed as a result of the call
      * @throws NullPointerException if the specified collection is null
      */
     public boolean addAll(Collection<? extends E> c) {
         return addAll(size, c);
     }

     /**
      * Inserts all of the elements in the specified collection into this
      * list, starting at the specified position.  Shifts the element
      * currently at that position (if any) and any subsequent elements to
      * the right (increases their indices).  The new elements will appear
      * in the list in the order that they are returned by the
      * specified collection's iterator.
      *
      * @param index index at which to insert the first element
      *              from the specified collection
      * @param c collection containing elements to be added to this list
      * @return {@code true} if this list changed as a result of the call
      * @throws IndexOutOfBoundsException {@inheritDoc}
      * @throws NullPointerException if the specified collection is null
      */
     public boolean addAll(int index, Collection<? extends E> c) {
         checkPositionIndex(index);

         Object[] a = c.toArray();
         int numNew = a.length;
         if (numNew == 0)
             return false;

         Node<E> pred, succ;
         if (index == size) {
             succ = null;
             pred = last;
         } else {
             succ = node(index);
             pred = succ.prev;
         }

         for (Object o : a) {
             @SuppressWarnings("unchecked") E e = (E) o;
             Node<E> newNode = new Node<>(pred, e, 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 += numNew;
         modCount++;
         return true;
     }

     /**
      * Removes all of the elements from this list.
      * The list will be empty after this call returns.
      */
     public void clear() {
         // Clearing all of the links between nodes is "unnecessary", but:
         // - helps a generational GC if the discarded nodes inhabit
         //   more than one generation
         // - is sure to free memory even if there is a reachable Iterator
         for (Node<E> x = first; x != null; ) {
             Node<E> next = x.next;
             x.item = null;
             x.next = null;
             x.prev = null;
             x = next;
         }
         first = last = null;
         size = 0;
         modCount++;
     }

     // Positional Access Operations

     /**
      * Returns the element at the specified position in this list.
      *
      * @param index index of the element to return
      * @return the element at the specified position in this list
      * @throws IndexOutOfBoundsException {@inheritDoc}
      */
     public E get(int index) {
         checkElementIndex(index);
         return node(index).item;
     }

     /**
      * Replaces the element at the specified position in this list with the
      * specified element.
      *
      * @param index index of the element to replace
      * @param element element to be stored at the specified position
      * @return the element previously at the specified position
      * @throws IndexOutOfBoundsException {@inheritDoc}
      */
     public E set(int index, E element) {
         checkElementIndex(index);
         Node<E> x = node(index);
         E oldVal = x.item;
         x.item = element;
         return oldVal;
     }

     /**
      * Inserts the specified element at the specified position in this list.
      * Shifts the element currently at that position (if any) and any
      * subsequent elements to the right (adds one to their indices).
      *
      * @param index index at which the specified element is to be inserted
      * @param element element to be inserted
      * @throws IndexOutOfBoundsException {@inheritDoc}
      */
     public void add(int index, E element) {
         checkPositionIndex(index);

         if (index == size)
             linkLast(element);
         else
             linkBefore(element, node(index));
     }

     /**
      * Removes the element at the specified position in this list.  Shifts any
      * subsequent elements to the left (subtracts one from their indices).
      * Returns the element that was removed from the list.
      *
      * @param index the index of the element to be removed
      * @return the element previously at the specified position
      * @throws IndexOutOfBoundsException {@inheritDoc}
      */
     public E remove(int index) {
         checkElementIndex(index);
         return unlink(node(index));
     }

     /**
      * Tells if the argument is the index of an existing element.
      */
     private boolean isElementIndex(int index) {
         return index >= 0 && index < size;
     }

     /**
      * Tells if the argument is the index of a valid position for an
      * iterator or an add operation.
      */
     private boolean isPositionIndex(int index) {
         return index >= 0 && index <= size;
     }

     /**
      * Constructs an IndexOutOfBoundsException detail message.
      * Of the many possible refactorings of the error handling code,
      * this "outlining" performs best with both server and client VMs.
      */
     private String outOfBoundsMsg(int index) {
         return "Index: "+index+", Size: "+size;
     }

     private void checkElementIndex(int index) {
         if (!isElementIndex(index))
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

     private void checkPositionIndex(int index) {
         if (!isPositionIndex(index))
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

     /**
      * Returns the (non-null) Node at the specified element index.
      */
     Node<E> node(int index) {
         // assert isElementIndex(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;
         }
     }

     // Search Operations

     /**
      * Returns the index of the first occurrence of the specified element
      * in this list, or -1 if this list does not contain the element.
      * More formally, returns the lowest index {@code i} such that
      * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
      * or -1 if there is no such index.
      *
      * @param o element to search for
      * @return the index of the first occurrence of the specified element in
      *         this list, or -1 if this list does not contain the element
      */
     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;
     }

     /**
      * Returns the index of the last occurrence of the specified element
      * in this list, or -1 if this list does not contain the element.
      * More formally, returns the highest index {@code i} such that
      * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
      * or -1 if there is no such index.
      *
      * @param o element to search for
      * @return the index of the last occurrence of the specified element in
      *         this list, or -1 if this list does not contain the element
      */
     public int lastIndexOf(Object o) {
         int index = size;
         if (o == null) {
             for (Node<E> x = last; x != null; x = x.prev) {
                 index--;
                 if (x.item == null)
                     return index;
             }
         } else {
             for (Node<E> x = last; x != null; x = x.prev) {
                 index--;
                 if (o.equals(x.item))
                     return index;
             }
         }
         return -1;
     }

     // Queue operations.

     /**
      * Retrieves, but does not remove, the head (first element) of this list.
      *
      * @return the head of this list, or {@code null} if this list is empty
      * @since 1.5
      */
     public E peek() {
         final Node<E> f = first;
         return (f == null) ? null : f.item;
     }

     /**
      * Retrieves, but does not remove, the head (first element) of this list.
      *
      * @return the head of this list
      * @throws NoSuchElementException if this list is empty
      * @since 1.5
      */
     public E element() {
         return getFirst();
     }

     /**
      * Retrieves and removes the head (first element) of this list.
      *
      * @return the head of this list, or {@code null} if this list is empty
      * @since 1.5
      */
     public E poll() {
         final Node<E> f = first;
         return (f == null) ? null : unlinkFirst(f);
     }

     /**
      * Retrieves and removes the head (first element) of this list.
      *
      * @return the head of this list
      * @throws NoSuchElementException if this list is empty
      * @since 1.5
      */
     public E remove() {
         return removeFirst();
     }

     /**
      * Adds the specified element as the tail (last element) of this list.
      *
      * @param e the element to add
      * @return {@code true} (as specified by {@link Queue#offer})
      * @since 1.5
      */
     public boolean offer(E e) {
         return add(e);
     }

     // Deque operations
     /**
      * Inserts the specified element at the front of this list.
      *
      * @param e the element to insert
      * @return {@code true} (as specified by {@link Deque#offerFirst})
      * @since 1.6
      */
     public boolean offerFirst(E e) {
         addFirst(e);
         return true;
     }

     /**
      * Inserts the specified element at the end of this list.
      *
      * @param e the element to insert
      * @return {@code true} (as specified by {@link Deque#offerLast})
      * @since 1.6
      */
     public boolean offerLast(E e) {
         addLast(e);
         return true;
     }

     /**
      * Retrieves, but does not remove, the first element of this list,
      * or returns {@code null} if this list is empty.
      *
      * @return the first element of this list, or {@code null}
      *         if this list is empty
      * @since 1.6
      */
     public E peekFirst() {
         final Node<E> f = first;
         return (f == null) ? null : f.item;
      }

     /**
      * Retrieves, but does not remove, the last element of this list,
      * or returns {@code null} if this list is empty.
      *
      * @return the last element of this list, or {@code null}
      *         if this list is empty
      * @since 1.6
      */
     public E peekLast() {
         final Node<E> l = last;
         return (l == null) ? null : l.item;
     }

     /**
      * Retrieves and removes the first element of this list,
      * or returns {@code null} if this list is empty.
      *
      * @return the first element of this list, or {@code null} if
      *     this list is empty
      * @since 1.6
      */
     public E pollFirst() {
         final Node<E> f = first;
         return (f == null) ? null : unlinkFirst(f);
     }

     /**
      * Retrieves and removes the last element of this list,
      * or returns {@code null} if this list is empty.
      *
      * @return the last element of this list, or {@code null} if
      *     this list is empty
      * @since 1.6
      */
     public E pollLast() {
         final Node<E> l = last;
         return (l == null) ? null : unlinkLast(l);
     }

     /**
      * Pushes an element onto the stack represented by this list.  In other
      * words, inserts the element at the front of this list.
      *
      * <p>This method is equivalent to {@link #addFirst}.
      *
      * @param e the element to push
      * @since 1.6
      */
     public void push(E e) {
         addFirst(e);
     }

     /**
      * Pops an element from the stack represented by this list.  In other
      * words, removes and returns the first element of this list.
      *
      * <p>This method is equivalent to {@link #removeFirst()}.
      *
      * @return the element at the front of this list (which is the top
      *         of the stack represented by this list)
      * @throws NoSuchElementException if this list is empty
      * @since 1.6
      */
     public E pop() {
         return removeFirst();
     }

     /**
      * Removes the first occurrence of the specified element in this
      * list (when traversing the list from head to tail).  If the list
      * does not contain the element, it is unchanged.
      *
      * @param o element to be removed from this list, if present
      * @return {@code true} if the list contained the specified element
      * @since 1.6
      */
     public boolean removeFirstOccurrence(Object o) {
         return remove(o);
     }

     /**
      * Removes the last occurrence of the specified element in this
      * list (when traversing the list from head to tail).  If the list
      * does not contain the element, it is unchanged.
      *
      * @param o element to be removed from this list, if present
      * @return {@code true} if the list contained the specified element
      * @since 1.6
      */
     public boolean removeLastOccurrence(Object o) {
         if (o == null) {
             for (Node<E> x = last; x != null; x = x.prev) {
                 if (x.item == null) {
                     unlink(x);
                     return true;
                 }
             }
         } else {
             for (Node<E> x = last; x != null; x = x.prev) {
                 if (o.equals(x.item)) {
                     unlink(x);
                     return true;
                 }
             }
         }
         return false;
     }

     /**
      * Returns a list-iterator of the elements in this list (in proper
      * sequence), starting at the specified position in the list.
      * Obeys the general contract of {@code List.listIterator(int)}.<p>
      *
      * The list-iterator is <i>fail-fast</i>: if the list is structurally
      * modified at any time after the Iterator is created, in any way except
      * through the list-iterator's own {@code remove} or {@code add}
      * methods, the list-iterator will throw a
      * {@code ConcurrentModificationException}.  Thus, in the face of
      * concurrent modification, the iterator fails quickly and cleanly, rather
      * than risking arbitrary, non-deterministic behavior at an undetermined
      * time in the future.
      *
      * @param index index of the first element to be returned from the
      *              list-iterator (by a call to {@code next})
      * @return a ListIterator of the elements in this list (in proper
      *         sequence), starting at the specified position in the list
      * @throws IndexOutOfBoundsException {@inheritDoc}
      * @see List#listIterator(int)
      */
     public ListIterator<E> listIterator(int index) {
         checkPositionIndex(index);
         return new ListItr(index);
     }

     private class ListItr implements ListIterator<E> {
         private Node<E> lastReturned = null;
         private Node<E> next;
         private int nextIndex;
         private int expectedModCount = modCount;

         ListItr(int index) {
             // assert isPositionIndex(index);
             next = (index == size) ? null : node(index);
             nextIndex = index;
         }

         public boolean hasNext() {
             return nextIndex < size;
         }

         public E next() {
             checkForComodification();
             if (!hasNext())
                 throw new NoSuchElementException();

             lastReturned = next;
             next = next.next;
             nextIndex++;
             return lastReturned.item;
         }

         public boolean hasPrevious() {
             return nextIndex > 0;
         }

         public E previous() {
             checkForComodification();
             if (!hasPrevious())
                 throw new NoSuchElementException();

             lastReturned = next = (next == null) ? last : next.prev;
             nextIndex--;
             return lastReturned.item;
         }

         public int nextIndex() {
             return nextIndex;
         }

         public int previousIndex() {
             return nextIndex - 1;
         }

         public void remove() {
             checkForComodification();
             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) {
             if (lastReturned == null)
                 throw new IllegalStateException();
             checkForComodification();
             lastReturned.item = e;
         }

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

         final void checkForComodification() {
             if (modCount != expectedModCount)
                 throw new ConcurrentModificationException();
         }
     }

     private static class Node<E> {
         E item;
         Node<E> next;
         Node<E> prev;

         Node(Node<E> prev, E element, Node<E> next) {
             this.item = element;
             this.next = next;
             this.prev = prev;
         }
     }

     /**
      * @since 1.6
      */
     public Iterator<E> descendingIterator() {
         return new DescendingIterator();
     }

     /**
      * Adapter to provide descending iterators via ListItr.previous
      */
     private class DescendingIterator implements Iterator<E> {
         private final ListItr itr = new ListItr(size());
         public boolean hasNext() {
             return itr.hasPrevious();
         }
         public E next() {
             return itr.previous();
         }
         public void remove() {
             itr.remove();
         }
     }

     @SuppressWarnings("unchecked")
     private LinkedList<E> superClone() {
         try {
             return (LinkedList<E>) super.clone();
         } catch (CloneNotSupportedException e) {
             throw new InternalError();
         }
     }

     /**
      * Returns a shallow copy of this {@code LinkedList}. (The elements
      * themselves are not cloned.)
      *
      * @return a shallow copy of this {@code LinkedList} instance
      */
     public Object clone() {
         LinkedList<E> clone = superClone();

         // Put clone into "virgin" state
         clone.first = clone.last = null;
         clone.size = 0;
         clone.modCount = 0;

         // Initialize clone with our elements
         for (Node<E> x = first; x != null; x = x.next)
             clone.add(x.item);

         return clone;
     }

     /**
      * Returns an array containing all of the elements in this list
      * in proper sequence (from first to last element).
      *
      * <p>The returned array will be "safe" in that no references to it are
      * maintained by this list.  (In other words, this method must allocate
      * a new array).  The caller is thus free to modify the returned array.
      *
      * <p>This method acts as bridge between array-based and collection-based
      * APIs.
      *
      * @return an array containing all of the elements in this list
      *         in proper sequence
      */
     public Object[] toArray() {
         Object[] result = new Object[size];
         int i = 0;
         for (Node<E> x = first; x != null; x = x.next)
             result[i++] = x.item;
         return result;
     }

     /**
      * Returns an array containing all of the elements in this list in
      * proper sequence (from first to last element); the runtime type of
      * the returned array is that of the specified array.  If the list fits
      * in the specified array, it is returned therein.  Otherwise, a new
      * array is allocated with the runtime type of the specified array and
      * the size of this list.
      *
      * <p>If the list fits in the specified array with room to spare (i.e.,
      * the array has more elements than the list), the element in the array
      * immediately following the end of the list is set to {@code null}.
      * (This is useful in determining the length of the list <i>only</i> if
      * the caller knows that the list does not contain any null elements.)
      *
      * <p>Like the {@link #toArray()} method, this method acts as bridge between
      * array-based and collection-based APIs.  Further, this method allows
      * precise control over the runtime type of the output array, and may,
      * under certain circumstances, be used to save allocation costs.
      *
      * <p>Suppose {@code x} is a list known to contain only strings.
      * The following code can be used to dump the list into a newly
      * allocated array of {@code String}:
      *
      * <pre>
      *     String[] y = x.toArray(new String[0]);</pre>
      *
      * Note that {@code toArray(new Object[0])} is identical in function to
      * {@code toArray()}.
      *
      * @param a the array into which the elements of the list are to
      *          be stored, if it is big enough; otherwise, a new array of the
      *          same runtime type is allocated for this purpose.
      * @return an array containing the elements of the list
      * @throws ArrayStoreException if the runtime type of the specified array
      *         is not a supertype of the runtime type of every element in
      *         this list
      * @throws NullPointerException if the specified array is null
      */
     @SuppressWarnings("unchecked")
     public <T> T[] toArray(T[] a) {
         if (a.length < size)
             a = (T[])java.lang.reflect.Array.newInstance(
                                 a.getClass().getComponentType(), size);
         int i = 0;
         Object[] result = a;
         for (Node<E> x = first; x != null; x = x.next)
             result[i++] = x.item;

         if (a.length > size)
             a[size] = null;

         return a;
     }

     private static final long serialVersionUID = 876323262645176354L;

     /**
      * Saves the state of this {@code LinkedList} instance to a stream
      * (that is, serializes it).
      *
      * @serialData The size of the list (the number of elements it
      *             contains) is emitted (int), followed by all of its
      *             elements (each an Object) in the proper order.
      */
     private void writeObject(java.io.ObjectOutputStream s)
         throws java.io.IOException {
         // Write out any hidden serialization magic
         s.defaultWriteObject();

         // Write out size
         s.writeInt(size);

         // Write out all elements in the proper order.
         for (Node<E> x = first; x != null; x = x.next)
             s.writeObject(x.item);
     }

     /**
      * Reconstitutes this {@code LinkedList} instance from a stream
      * (that is, deserializes it).
      */
     @SuppressWarnings("unchecked")
     private void readObject(java.io.ObjectInputStream s)
         throws java.io.IOException, ClassNotFoundException {
         // Read in any hidden serialization magic
         s.defaultReadObject();

         // Read in size
         int size = s.readInt();

         // Read in all elements in the proper order.
         for (int i = 0; i < size; i++)
             linkLast((E)s.readObject());
     }
 }

总结：
(01) LinkedList 实际上是通过双向链表去实现的。
        它包含一个非常重要的内部类：Entry。Entry是双向链表节点所对应的数据结构，它包括的属性有：当前节点所包含的值，上一个节点，下一个节点。
(02) 从LinkedList的实现方式中可以发现，它不存在LinkedList容量不足的问题。
(03) LinkedList的克隆函数，即是将全部元素克隆到一个新的LinkedList对象中。
(04) LinkedList实现java.io.Serializable。当写入到输出流时，先写入“容量”，再依次写入“每一个节点保护的值”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。
(05) 由于LinkedList实现了Deque，而Deque接口定义了在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作）。

总结起来如下表格：

        第一个元素（头部）                 最后一个元素（尾部）
        抛出异常        特殊值            抛出异常        特殊值
插入    addFirst(e)    offerFirst(e)    addLast(e)        offerLast(e)
移除    removeFirst()  pollFirst()      removeLast()    pollLast()
检查    getFirst()     peekFirst()      getLast()        peekLast()

(06) LinkedList可以作为FIFO(先进先出)的队列，作为FIFO的队列时，下表的方法等价：

队列方法       等效方法
add(e)        addLast(e)
offer(e)      offerLast(e)
remove()      removeFirst()
poll()        pollFirst()
element()     getFirst()
peek()        peekFirst()

(07) LinkedList可以作为LIFO(后进先出)的栈，作为LIFO的栈时，下表的方法等价：

栈方法        等效方法
push(e)      addFirst(e)
pop()        removeFirst()
peek()       peekFirst()

• 增
• addFirst(e)和offerFirst(e): 查的, 说addXxx是继承自List的, offerXxx是来自Queue.
• addLast(e)和offerLast(e)
• 获取: 获取,但不删除元素。
• getFirst()和peakFirst(): 如果集合为空, 前者抛异常, 后者获取null. 
• getLast()和peakLast(): 同上
• 删: 获取,且删除元素。
• removeFirst()和pollFirst(): 如果集合为空, 前者抛异常, 后者获取null. 
• remove()和poll(): 同上
• removeLast()和pollLast(): 同上

第4部分 LinkedList遍历方式

LinkedList遍历方式

LinkedList支持多种遍历方式。建议不要采用随机访问的方式去遍历LinkedList，而采用逐个遍历的方式。
(01) 第一种，通过迭代器遍历。即通过Iterator去遍历。

for(Iterator iter = list.iterator(); iter.hasNext();)
    iter.next();

(02) 通过快速随机访问遍历LinkedList

int size = list.size();
for (int i=0; i<size; i++) {
    list.get(i);
}

(03) 通过另外一种for循环来遍历LinkedList

for (Integer integ:list)
    ;

(04) 通过pollFirst()来遍历LinkedList

while(list.pollFirst() != null)
    ;

(05) 通过pollLast()来遍历LinkedList

while(list.pollLast() != null)
    ;

(06) 通过removeFirst()来遍历LinkedList

try {
    while(list.removeFirst() != null)
        ;
} catch (NoSuchElementException e) {
}

(07) 通过removeLast()来遍历LinkedList

try {
    while(list.removeLast() != null)
        ;
} catch (NoSuchElementException e) {
}

测试这些遍历方式效率的代码如下：

 /**
  * linkedList
  * @ClassName: LinkedList_test_1
  * @Description:
  * @author Xingle
  * @date 2014-5-20 上午9:48:33
  *
  */
 public class LinkedList_test_1 {

     public static void main(String[] args) {

         // 通过Iterator遍历LinkedList
         iteratorLinkedListThruIterator((LinkedList<Integer>) getLinkedList());
         // 通过快速随机访问遍历LinkedList
         iteratorLinkedListThruForeach((LinkedList<Integer>) getLinkedList());
         // 通过for循环的变种来访问遍历LinkedList
         iteratorThroughFor2((LinkedList<Integer>) getLinkedList());
         // 通过PollFirst()遍历LinkedList
         iteratorThroughPollFirst((LinkedList<Integer>) getLinkedList());
         // 通过PollLast()遍历LinkedList
         iteratorThroughPollLast((LinkedList<Integer>) getLinkedList());
         // 通过removeFirst()遍历LinkedList
         iteratorThroughRemoveFirst((LinkedList<Integer>) getLinkedList());
         // 通过removeLast()遍历LinkedList
         iteratorThroughRemoveLast((LinkedList<Integer>) getLinkedList());
     }

     /**
      * 通过RemoveLast()来遍历LinkedList
      * @param
      * @return
      * @author xingle
      * @data 2014-5-22 上午11:59:11
      */
     private static void iteratorThroughRemoveLast(LinkedList<Integer> list) {
         String name = "iteratorThroughRemoveFirst:";
         if (list == null)
             return;
         long start = getCurrentTime();
         try {
             while (list.removeLast() != null)
                 ;
         } catch (NoSuchElementException e) {

         }
         long end = getCurrentTime();
         long interval = end - start;
         getPrint(name, interval);

     }

     /**
      * 通过RemoveFirst()来遍历LinkedList
      * @param
      * @return
      * @author xingle
      * @data 2014-5-22 上午11:58:36
      */
     private static void iteratorThroughRemoveFirst(LinkedList<Integer> list) {
         String name = "iteratorThroughRemoveFirst:";
         if (list == null)
             return;
         long start = getCurrentTime();
         try {
             while (list.removeFirst() != null)
                 ;
         } catch (NoSuchElementException e) {
         }
         long end = getCurrentTime();
         long interval = end - start;
         getPrint(name, interval);

     }

     /**
      * 通过pollLast()来遍历LinkedList
      * @param
      * @return
      * @author xingle
      * @data 2014-5-22 上午11:57:37
      */
     private static void iteratorThroughPollLast(LinkedList<Integer> list) {
         String name = "iteratorThroughPollLast:";
         if (list == null)
             return;
         long start = getCurrentTime();
         while (list.pollLast() != null)
             ;
         long end = getCurrentTime();
         long interval = end - start;
         getPrint(name, interval);

     }

     /**
      * 通过pollFirst()来遍历LinkedList
      * @param
      * @return
      * @author xingle
      * @data 2014-5-22 上午11:48:59
      */
     private static void iteratorThroughPollFirst(LinkedList<Integer> list) {
         String name = "iteratorThroughPollFirst:";
         if (list == null)
             return;
         long start = getCurrentTime();
         while (list.pollFirst() != null)
             ;
         long end = getCurrentTime();
         long interval = end - start;
         getPrint(name, interval);
     }

     /**
      *
      * @Description:
      * @param
      * @return
      * @author xingle
      * @data 2014-5-22 上午11:54:10
      */
     private static void getPrint(String name, long interval) {
         System.out.println(name + interval + " ms");

     }

     /**
      * 获取当前时间
      * @Description:
      * @param
      * @return
      * @author xingle
      * @data 2014-5-22 上午11:50:29
      */
     private static long getCurrentTime() {
         long start = System.currentTimeMillis();
         return start;
     }

     /**
      * 通过快速随机访问遍历LinkedList
      *
      * @Description:
      * @param
      * @return
      * @author xingle
      * @data 2014-5-22 上午11:32:33
      */
     private static void iteratorThroughFor2(LinkedList<Integer> list) {
         String name = "iteratorLinkedListByForeachRandomAccess:";
         if (list == null)
             return;
         long start = getCurrentTime();
         int size = list.size();
         for (int i = 0; i < size; i++) {
             list.get(i);
         }
         long end = getCurrentTime();
         long interval = end - start;
         getPrint(name, interval);
     }

     /**
      * 通过另外一种for循环来遍历LinkedList
      *
      * @Description:
      * @param
      * @return
      * @author xingle
      * @data 2014-5-22 上午11:32:31
      */
     private static void iteratorLinkedListThruForeach(LinkedList<Integer> list) {
         String name = "iteratorThroughForEach:";
         if (list == null)
             return;
         long start = getCurrentTime();
         for (Integer i : list)
             ;
         long end = getCurrentTime();
         long interval = end - start;
         getPrint(name, interval);
     }

     /**
      * 通过快迭代器遍历LinkedList
      *
      * @Description:
      * @param
      * @return
      * @author xingle
      * @data 2014-5-22 上午11:32:23
      */
     private static void iteratorLinkedListThruIterator(LinkedList<Integer> list) {
         String name = "iteratorLinkedListThruIterator:";
         if (list == null)
             return;
         long start = getCurrentTime();

         for (Iterator<Integer> iter = list.iterator(); iter.hasNext();)
             iter.next();
         long end = getCurrentTime();
         long interval = end - start;
         getPrint(name, interval);
     }

     /**
      *
      * @Description:
      * @param
      * @return
      * @author xingle
      * @data 2014-5-22 上午11:31:58
      */
     private static Object getLinkedList() {
         LinkedList<Integer> ls = new LinkedList<>();
         for (int i = 0; i < 100000; i++)
             ls.addLast(i);

         return ls;
     }

 }

执行结果：

iteratorLinkedListThruIterator:13 ms
iteratorThroughForEach:9 ms
iteratorLinkedListByForeachRandomAccess:6886 ms
iteratorThroughPollFirst:7 ms
iteratorThroughPollLast:7 ms
iteratorThroughRemoveFirst:5 ms
iteratorThroughRemoveFirst:5 ms

由此可见，遍历LinkedList时，使用removeFist()或removeLast()效率最高。但用它们遍历时，会删除原始数据；若单纯只读取，而不删除，应该使用第3种遍历方式。
无论如何，千万不要通过随机访问去遍历LinkedList！

---

转载：http://www.cnblogs.com/skywang12345/p/3308807.html