LinkedList源码分析（1.7.0_80）

定义

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

AbstractSequentialList：功能主要继承者，主要实现依靠ListIterator，ListIterator继承Iterator，LinkedList中需要实现ListIterator中的方法，避免父类复杂度。
Deque：双向列表继承
不支持同步修改：主要依靠modCount即fail-fast机制

属性

transient int size = 0; 大小
transient Node first; 首节点
transient Node 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;        }    }

定义前中后三个对象

初始化

   public LinkedList() {    }

  public LinkedList(Collection<? extends E> c) {        this();        addAll(c);    }

主要方法

linkFirst

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

作用：将e作为第一个元素
解析：首先获取原第一节点f，构建newNode，此节点前元素为null，中为e，后元素为f，将newNode作为第一个节点，若f为空则LinkedList只有newNode一个节点，否则原第一个节点f的前元素指向newNode。

linkLast

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

作用：将e作为最后一个元素。
解析：大致原理同linkFirst相同，构建的newNode 后元素为null，区别两者用不同的访问级别private和protected,暂未明白其中原理，两者都不能被外界调用。

linkBefore

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

作用：在一个节点前插入元素e
解析：获得当前节点的前元素，构建newNode ，其中e的后元素为succ，将succ原前元素指向newNode ，e的前元素为pred，原pred的后元素还是指向succ节点，所以pred.next = newNode;若pred 为null则succ为first节点，最好画图理解。

unlinkFirst

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

作用：去除第一个非空节点
解析：将节点中元素置空，后元素置空，后节点至成first节点，first节点特点，前元素为null，若next为空则LinkedList为空，并返回中元素，外部不可调用

unlinkLast

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

作用：去除最后一个非空节点
解析：原理同unlinkFirst差不多，last特点后元素为null所以prev.next = null;

unlink

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

作用：取出一个非空节点
原理：大致同上相同，prev == null，若x的前节点为空，则x为first节点，x置空后则它的后节点为first节点，next的前节点为x，x置空后为null，next满足作为fist节点要求（前元素为null），由此可知当last，first同时为null时LinkedList为空，同是指向一个节点LinkedList只有一个元素。此方法不可外部调用

getFirst

public E getFirst() {        final Node<E> f = first;        if (f == null)            throw new NoSuchElementException();        return f.item;    }

作用：返回first节点中元素

getLast

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

作用：返回last中元素

removeFirst

 public E removeFirst() {        final Node<E> f = first;        if (f == null)            throw new NoSuchElementException();        return unlinkFirst(f);    }

作用：移除第一个节点，返回中元素
解析：参考unlinkFirst

addFirst

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

作用：同linkFirst

addLast

public void addLast(E e) {        linkLast(e);    }

作用：同linkLast

contains

public boolean contains(Object o) {        return indexOf(o) != -1;    }

作用：是否包含元素o

indexOf

    public int indexOf(Object o) {        int index = 0;        if (o == null) {            for (Node<E> x = first; x != null; x = x.next) {                if (x.item == null)                    return index;                index++;            }        } else {            for (Node<E> x = first; x != null; x = x.next) {                if (o.equals(x.item))                    return index;                index++;            }        }        return -1;    }

作用：返回此元素在结合中的第一个下标，若无为-1

add

public boolean add(E e) {        linkLast(e);        return true;    }

作用：在结合末尾添加一个元素

remove

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

作用：删除o在集合中第一次出现的位置
解析：参考unlink

addAll(Collection

  public boolean addAll(Collection<? extends E> c) {        return addAll(size, c);    }

作用：将集合c插入LinkedList中，正序返回

addAll(int index, Collection

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

作用：从指定位置开始将集合c插入到LinkedList中
解析：checkPositionIndex使index最大只能为LinkedList的size，

clone

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

作用：LinkedList浅拷贝

toArray(T[] a)

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