java1.7集合源码阅读：LinkedList

先看看类定义：

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

LinkedList与ArrayList相比，LinkedList不再实现RandomAccess接口，表明不支持快速随机访问数据，但实现了Deque接口，可当队列使用，Deque继承自Queue,接口定义：

 public interface Queue<E> extends Collection<E> {
         void addFirst(E e);
         void addLast(E e);
         boolean offerFirst(E e);
         boolean offerLast(E e);
         E removeFirst();
         E removeLast();
         E pollFirst();
         E pollLast();
         E getFirst();
         E getLast();
         E peekFirst();
         E peekLast();
         boolean removeFirstOccurrence(Object o);
         boolean removeLastOccurrence(Object o);
         boolean add(E e);
         boolean offer(E e);
         E remove();
         E poll();
         E element();
         E peek();
         void push(E e);
         boolean remove(Object o);
         boolean contains(Object o);
         public int size();
         Iterator<E> iterator();
         Iterator<E> descendingIterator();
28　}

看看LinkedList的两个属性，一个头节点，一个末节点：

     /**
      * 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;

在看看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;
         }
     }

Node中保存着存入集合的对象，同时也保存着上一个节点和下一个节点，由此可知，LinkedList 内部采用的是双向链表结构。

再看看CRUD操作:

add:

     /**
      * 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);     //last节点后拼接一个节点
         return true;
     }
     /**
      * 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;  // 将last节点指向当前新创建的节点，新节点变为last节点，原last节点的下一个节点指向最新的last节点

 　　　if (l == null)
 　　　　first = newNode;
 　　else 
 　　　　l.next = newNode; 
 　　size++; 
 　　modCount++;
 }

与linkLast对应的还有linkFirst:

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

既然存在在对尾、队尾添加元素，那么是不是也应该存在在指定某个元素之前或之后添加元素呢，是的，的确存在：

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

与此同时也还存在另外两个方法，一个是在指定节点位置添加元素，另一个是将指定位置的元素修改成当前元素：

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

linkedList  虽然提供了get(index) 方法，但并不没有ArrayList那样高效的获取，而是变量整个数据结构，此时，做了一个优化，根据index判断元素是在链表的前端还是后端，如果是后端，则从队尾开始遍历：

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

获取对首或队尾元素就简单了，直接返回对首或队尾元素就ok了：

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

LinkedList 无参remove方法，是直接删除队首元素：

   /**
      * 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();
     }
     /**
      * 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);
     }
     /**
      * Unlinks non-null first node f.
      */
     private E unlinkFirst(Node<E> f) {  //将对首元素设置null,将对首的下一元素作为对首元素
         // 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;
     }

remove(Object),变量整个数据结构删除：

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

linkedList实现了队列接口，使用中也可以直接当队列用：

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

linkedList 还提供了几个方法，可以直接通过peek方法获取元素，需要注意的是获取之后并不会从队列中删除该元素：

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

与peek对应的还有poll方法，同样是获取元素，不同点在于，获取元素之后，该元素将会从队列中删除。

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

LinkedList提供了多种操作数据集合的方法，但最重要的一点就是，整个是实现是非线程安全的，在多线程下需要进行同步处理，或者使用并发包中的对应实现类。