【Java集合系列二】LinkedList解析

一、简介

1、LinkedList继承关系

2、LinkedList底层实现

LinkedList使用双向链表存储数据，所以没有默认的容量，也不会有扩容一说。只有两个指针，永远指向链表的两端：first和last。定义了一个size属性，用于记录当前存储的元素个数。内部自定义了Node类，如下：

3、LinkedList中meta方法

所有对外暴露的方法其实都是对少数几个方法的包装，比如linkFirst(E e)、linkLast(E e)、node(int index)等，重点研究着几个方法即可快速了解LinkedList；

二、主要方法

1、void linkFirst(E e)

addFirst(E e)方法使用了改方法，将e元素作为第一个元素

2、linkLast(E e)

addLast(E e)、add(E e)、add(int index, E e)等方法有使用

3、linkBefore(E e, Node<E> succ)

add(int index, E e)方法有使用

4、E unlinkFirst(Node<E> f)

removeFirst()、poll()、pollFirst()等方法有使用，作用就是移除元素f，一般这里传入的f都会是第一个元素，所以下面的代码中没有清理f的前一个元素。

5、E unlinkLast(Node<E> l)

removeLast()、pollLast()等方法有使用，和unlinkFirst()原理类似

6、E unlink(Node<E> x)

这个方法就是真正的移除元素x， 这里假设x前后都有元素的，稍微复杂些

7、Node<E> node(int index)

根据index，获取到index位置对应的Node<E>元素。这里采取了二分策略，判断index所在的区域，缩小范围，提高查找效率

有2个点值得注意：

1、遍历时，i要么大于index，要么小于index，都不等于index，这是因为x=x.next或者x=x.prev这句导致的；

2、倒序遍历时，从size位置往前遍历；

8、关于set(int index, E e)

LinkedList的set(int index, E e)方法实现比较特殊，首先根据index获取到listIterator，取到listIterator的当前位置的元素，然后替换掉其中E。有点想不明白为什么要采取这种方式，使用node(int index)方法取到元素，直接替换不是更好？

猜测的原因：

LinkedList并非直接继承自AbstractList，而是继承自AbstractSequentList，set(int index, E e)方法是在AbstractSequentList中实现的，这个方法中并没有之前提到的node(int index)方法，但是有listIterator()方法，所以要么不要在父类中实现set()，要么得使用父类中存在的方法来实现，尽管listIterator()方法是抽象的。

9、结尾

以上这些方法都是私有的，但是其他很多public的方法都是基于这几个方法实现的。另外LinkedList提供了类似队列/双头队列操作的几个方法，同时实现了ListItr，提供向前向后遍历，但是没有提供subList方法。

源码如下：

 package java.util;

 import java.util.function.Consumer;

 /**
  * Doubly-linked list implementation of the {@code List} and {@code Deque}
  * interfaces.  Implements all optional list operations, and permits all
  * elements (including {@code null}).
  *
  * <p>All of the operations perform as could be expected for a doubly-linked
  * list.  Operations that index into the list will traverse the list from
  * the beginning or the end, whichever is closer to the specified index.
  *
  * <p><strong>Note that this implementation is not synchronized.</strong>
  * If multiple threads access a linked list concurrently, and at least
  * one of the threads modifies the list structurally, it <i>must</i> be
  * synchronized externally.  (A structural modification is any operation
  * that adds or deletes one or more elements; merely setting the value of
  * an element is not a structural modification.)  This is typically
  * accomplished by synchronizing on some object that naturally
  * encapsulates the list.
  *
  * If no such object exists, the list should be "wrapped" using the
  * {@link Collections#synchronizedList Collections.synchronizedList}
  * method.  This is best done at creation time, to prevent accidental
  * unsynchronized access to the list:<pre>
  *   List list = Collections.synchronizedList(new LinkedList(...));</pre>
  *
  * <p>The iterators returned by this class's {@code iterator} and
  * {@code listIterator} methods are <i>fail-fast</i>: if the list is
  * structurally modified at any time after the iterator is created, in
  * any way except through the Iterator's own {@code remove} or
  * {@code add} methods, the iterator will throw a {@link
  * 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.
  *
  * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
  * as it is, generally speaking, impossible to make any hard guarantees in the
  * presence of unsynchronized concurrent modification.  Fail-fast iterators
  * throw {@code ConcurrentModificationException} on a best-effort basis.
  * Therefore, it would be wrong to write a program that depended on this
  * exception for its correctness:   <i>the fail-fast behavior of iterators
  * should be used only to detect bugs.</i>
  *
  * <p>This class is a member of the
  * <a href="{@docRoot}/../technotes/guides/collections/index.html">
  * Java Collections Framework</a>.
  *
  * @author  Josh Bloch
  * @see     List
  * @see     ArrayList
  * @since 1.2
  * @param <E> the type of elements held in this collection
  */

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

         public void forEachRemaining(Consumer<? super E> action) {
             Objects.requireNonNull(action);
             while (modCount == expectedModCount && nextIndex < size) {
                 action.accept(next.item);
                 lastReturned = next;
                 next = next.next;
                 nextIndex++;
             }
             checkForComodification();
         }

         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(e);
         }
     }

     /**
      * 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());
     }

     /**
      * Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>
      * and <em>fail-fast</em> {@link Spliterator} over the elements in this
      * list.
      *
      * <p>The {@code Spliterator} reports {@link Spliterator#SIZED} and
      * {@link Spliterator#ORDERED}.  Overriding implementations should document
      * the reporting of additional characteristic values.
      *
      * @implNote
      * The {@code Spliterator} additionally reports {@link Spliterator#SUBSIZED}
      * and implements {@code trySplit} to permit limited parallelism..
      *
      * @return a {@code Spliterator} over the elements in this list
      * @since 1.8
      */
     @Override
     public Spliterator<E> spliterator() {
         return new LLSpliterator<E>(this, -1, 0);
     }

     /** A customized variant of Spliterators.IteratorSpliterator */
     static final class LLSpliterator<E> implements Spliterator<E> {
         static final int BATCH_UNIT = 1 << 10;  // batch array size increment
         static final int MAX_BATCH = 1 << 25;  // max batch array size;
         final LinkedList<E> list; // null OK unless traversed
         Node<E> current;      // current node; null until initialized
         int est;              // size estimate; -1 until first needed
         int expectedModCount; // initialized when est set
         int batch;            // batch size for splits

         LLSpliterator(LinkedList<E> list, int est, int expectedModCount) {
             this.list = list;
             this.est = est;
             this.expectedModCount = expectedModCount;
         }

         final int getEst() {
             int s; // force initialization
             final LinkedList<E> lst;
             if ((s = est) < 0) {
                 if ((lst = list) == null)
                     s = est = 0;
                 else {
                     expectedModCount = lst.modCount;
                     current = lst.first;
                     s = est = lst.size;
                 }
             }
             return s;
         }

         public long estimateSize() { return (long) getEst(); }

         public Spliterator<E> trySplit() {
             Node<E> p;
             int s = getEst();
             if (s > 1 && (p = current) != null) {
                 int n = batch + BATCH_UNIT;
                 if (n > s)
                     n = s;
                 if (n > MAX_BATCH)
                     n = MAX_BATCH;
                 Object[] a = new Object[n];
                 int j = 0;
                 do { a[j++] = p.item; } while ((p = p.next) != null && j < n);
                 current = p;
                 batch = j;
                 est = s - j;
                 return Spliterators.spliterator(a, 0, j, Spliterator.ORDERED);
             }
             return null;
         }

         public void forEachRemaining(Consumer<? super E> action) {
             Node<E> p; int n;
             if (action == null) throw new NullPointerException();
             if ((n = getEst()) > 0 && (p = current) != null) {
                 current = null;
                 est = 0;
                 do {
                     E e = p.item;
                     p = p.next;
                     action.accept(e);
                 } while (p != null && --n > 0);
             }
             if (list.modCount != expectedModCount)
                 throw new ConcurrentModificationException();
         }

         public boolean tryAdvance(Consumer<? super E> action) {
             Node<E> p;
             if (action == null) throw new NullPointerException();
             if (getEst() > 0 && (p = current) != null) {
                 --est;
                 E e = p.item;
                 current = p.next;
                 action.accept(e);
                 if (list.modCount != expectedModCount)
                     throw new ConcurrentModificationException();
                 return true;
             }
             return false;
         }

         public int characteristics() {
             return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
         }
     }

 }

AbstractSequentialList.java

 package java.util;

 /**
  * This class provides a skeletal implementation of the <tt>List</tt>
  * interface to minimize the effort required to implement this interface
  * backed by a "sequential access" data store (such as a linked list).  For
  * random access data (such as an array), <tt>AbstractList</tt> should be used
  * in preference to this class.<p>
  *
  * This class is the opposite of the <tt>AbstractList</tt> class in the sense
  * that it implements the "random access" methods (<tt>get(int index)</tt>,
  * <tt>set(int index, E element)</tt>, <tt>add(int index, E element)</tt> and
  * <tt>remove(int index)</tt>) on top of the list's list iterator, instead of
  * the other way around.<p>
  *
  * To implement a list the programmer needs only to extend this class and
  * provide implementations for the <tt>listIterator</tt> and <tt>size</tt>
  * methods.  For an unmodifiable list, the programmer need only implement the
  * list iterator's <tt>hasNext</tt>, <tt>next</tt>, <tt>hasPrevious</tt>,
  * <tt>previous</tt> and <tt>index</tt> methods.<p>
  *
  * For a modifiable list the programmer should additionally implement the list
  * iterator's <tt>set</tt> method.  For a variable-size list the programmer
  * should additionally implement the list iterator's <tt>remove</tt> and
  * <tt>add</tt> methods.<p>
  *
  * The programmer should generally provide a void (no argument) and collection
  * constructor, as per the recommendation in the <tt>Collection</tt> interface
  * specification.<p>
  *
  * This class is a member of the
  * <a href="{@docRoot}/../technotes/guides/collections/index.html">
  * Java Collections Framework</a>.
  *
  * @author  Josh Bloch
  * @author  Neal Gafter
  * @see Collection
  * @see List
  * @see AbstractList
  * @see AbstractCollection
  * @since 1.2
  */

 public abstract class AbstractSequentialList<E> extends AbstractList<E> {
     /**
      * Sole constructor.  (For invocation by subclass constructors, typically
      * implicit.)
      */
     protected AbstractSequentialList() {
     }

     /**
      * Returns the element at the specified position in this list.
      *
      * <p>This implementation first gets a list iterator pointing to the
      * indexed element (with <tt>listIterator(index)</tt>).  Then, it gets
      * the element using <tt>ListIterator.next</tt> and returns it.
      *
      * @throws IndexOutOfBoundsException {@inheritDoc}
      */
     public E get(int index) {
         try {
             return listIterator(index).next();
         } catch (NoSuchElementException exc) {
             throw new IndexOutOfBoundsException("Index: "+index);
         }
     }

     /**
      * Replaces the element at the specified position in this list with the
      * specified element (optional operation).
      *
      * <p>This implementation first gets a list iterator pointing to the
      * indexed element (with <tt>listIterator(index)</tt>).  Then, it gets
      * the current element using <tt>ListIterator.next</tt> and replaces it
      * with <tt>ListIterator.set</tt>.
      *
      * <p>Note that this implementation will throw an
      * <tt>UnsupportedOperationException</tt> if the list iterator does not
      * implement the <tt>set</tt> operation.
      *
      * @throws UnsupportedOperationException {@inheritDoc}
      * @throws ClassCastException            {@inheritDoc}
      * @throws NullPointerException          {@inheritDoc}
      * @throws IllegalArgumentException      {@inheritDoc}
      * @throws IndexOutOfBoundsException     {@inheritDoc}
      */
     public E set(int index, E element) {
         try {
             ListIterator<E> e = listIterator(index);
             E oldVal = e.next();
             e.set(element);
             return oldVal;
         } catch (NoSuchElementException exc) {
             throw new IndexOutOfBoundsException("Index: "+index);
         }
     }

     /**
      * Inserts the specified element at the specified position in this list
      * (optional operation).  Shifts the element currently at that position
      * (if any) and any subsequent elements to the right (adds one to their
      * indices).
      *
      * <p>This implementation first gets a list iterator pointing to the
      * indexed element (with <tt>listIterator(index)</tt>).  Then, it
      * inserts the specified element with <tt>ListIterator.add</tt>.
      *
      * <p>Note that this implementation will throw an
      * <tt>UnsupportedOperationException</tt> if the list iterator does not
      * implement the <tt>add</tt> operation.
      *
      * @throws UnsupportedOperationException {@inheritDoc}
      * @throws ClassCastException            {@inheritDoc}
      * @throws NullPointerException          {@inheritDoc}
      * @throws IllegalArgumentException      {@inheritDoc}
      * @throws IndexOutOfBoundsException     {@inheritDoc}
      */
     public void add(int index, E element) {
         try {
             listIterator(index).add(element);
         } catch (NoSuchElementException exc) {
             throw new IndexOutOfBoundsException("Index: "+index);
         }
     }

     /**
      * Removes the element at the specified position in this list (optional
      * operation).  Shifts any subsequent elements to the left (subtracts one
      * from their indices).  Returns the element that was removed from the
      * list.
      *
      * <p>This implementation first gets a list iterator pointing to the
      * indexed element (with <tt>listIterator(index)</tt>).  Then, it removes
      * the element with <tt>ListIterator.remove</tt>.
      *
      * <p>Note that this implementation will throw an
      * <tt>UnsupportedOperationException</tt> if the list iterator does not
      * implement the <tt>remove</tt> operation.
      *
      * @throws UnsupportedOperationException {@inheritDoc}
      * @throws IndexOutOfBoundsException     {@inheritDoc}
      */
     public E remove(int index) {
         try {
             ListIterator<E> e = listIterator(index);
             E outCast = e.next();
             e.remove();
             return outCast;
         } catch (NoSuchElementException exc) {
             throw new IndexOutOfBoundsException("Index: "+index);
         }
     }

     // Bulk Operations

     /**
      * Inserts all of the elements in the specified collection into this
      * list at the specified position (optional operation).  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 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.)
      *
      * <p>This implementation gets an iterator over the specified collection and
      * a list iterator over this list pointing to the indexed element (with
      * <tt>listIterator(index)</tt>).  Then, it iterates over the specified
      * collection, inserting the elements obtained from the iterator into this
      * list, one at a time, using <tt>ListIterator.add</tt> followed by
      * <tt>ListIterator.next</tt> (to skip over the added element).
      *
      * <p>Note that this implementation will throw an
      * <tt>UnsupportedOperationException</tt> if the list iterator returned by
      * the <tt>listIterator</tt> method does not implement the <tt>add</tt>
      * operation.
      *
      * @throws UnsupportedOperationException {@inheritDoc}
      * @throws ClassCastException            {@inheritDoc}
      * @throws NullPointerException          {@inheritDoc}
      * @throws IllegalArgumentException      {@inheritDoc}
      * @throws IndexOutOfBoundsException     {@inheritDoc}
      */
     public boolean addAll(int index, Collection<? extends E> c) {
         try {
             boolean modified = false;
             ListIterator<E> e1 = listIterator(index);
             Iterator<? extends E> e2 = c.iterator();
             while (e2.hasNext()) {
                 e1.add(e2.next());
                 modified = true;
             }
             return modified;
         } catch (NoSuchElementException exc) {
             throw new IndexOutOfBoundsException("Index: "+index);
         }
     }

     // Iterators

     /**
      * Returns an iterator over the elements in this list (in proper
      * sequence).<p>
      *
      * This implementation merely returns a list iterator over the list.
      *
      * @return an iterator over the elements in this list (in proper sequence)
      */
     public Iterator<E> iterator() {
         return listIterator();
     }

     /**
      * Returns a list iterator over the elements in this list (in proper
      * sequence).
      *
      * @param  index index of first element to be returned from the list
      *         iterator (by a call to the <code>next</code> method)
      * @return a list iterator over the elements in this list (in proper
      *         sequence)
      * @throws IndexOutOfBoundsException {@inheritDoc}
      */
     public abstract ListIterator<E> listIterator(int index);
 }