LinkedList原理讲解

一. LinkedList概述

本节基于JDK1.8.0_60

1. LinkedList是双向链表实现的List
2. LinkedList是非线程安全的
3. LinkedList元素允许为null，允许重复元素
4. LinkedList是基于链表实现的，因此插入删除效率高，查找效率低（虽然有一个加速动作）
5. LinkedList是基于链表实现的，因此不存在容量不足的问题，所以没有扩容的方法
6. LinkedList还实现了栈和队列的操作方法，因此也可以作为栈、队列和双端队列来使用
7. 源码解析：LinkedList源码
8. 参考：图解集合2：LinkedList
   

二. LinkedList总结

2.1 LinkedList存储结构

// 元素个数transient int size = 0;/** * 指向第一个节点的指针 * 不变性: * 1. 如果first = null，则last=null * 2. 如果first.prev == null，则first.item != null */transient Node<E> first;/** * 指向最后一个节点的指针 * 不变性: * 1. 如果first = null，则last = null * 2. 如果last.next == null，则last.item != null */transient Node<E> last;private static class Node<E> {    E item;    Node<E> next; // 下一个Node的引用    Node<E> prev; // 上一个Node的引用    Node(Node<E> prev, E element, Node<E> next) {        this.item = element;        this.next = next;        this.prev = prev;    }}/** * 创建一个空list * */public LinkedList() {}public LinkedList(Collection<? extends E> c) {    this();    addAll(c);}

Java的serialization提供了一种持久化对象实例的机制。用transient关键字标记的成员变量不参与序列化过程，非transient型的变量才会被序列化。

2.2 添加元素add

2.2.2 头插入

// 从头插入public void addFirst(E e) {    linkFirst(e);}private void linkFirst(E e) {    final Node<E> f = first;    final Node<E> newNode = new Node<>(null, e, f);    first = newNode;    if (f == null) // 当前List中没有元素，size=0        last = newNode;    else        f.prev = newNode;    size++;    modCount++;}

2.2.2 尾插入

public boolean add(E e) {    linkLast(e);    return true;}public void addLast(E e) {    linkLast(e);}void linkLast(E e) {    final Node<E> l = last;    final Node<E> newNode = new Node<>(l, e, null);    last = newNode;    if (l == null)// 当前List中没有元素，size=0        first = newNode;    else        l.next = newNode;    size++;    modCount++;}

2.2.3 中间插入

public void add(int index, E element) {    // 检查位置索引index    checkPositionIndex(index);    if (index == size)// 尾插入        linkLast(element);    else // 中间插入        linkBefore(element, node(index));}Node<E> node(int index) {    if (index < (size >> 1)) {// index在前半部分        Node<E> x = first;        for (int i = 0; i < index; i++)            x = x.next;        return x;    } else {// index在后半部分        Node<E> x = last;        for (int i = size - 1; i > index; i--)            x = x.prev;        return x;    }}// 在节点succ插入evoid linkBefore(E e, Node<E> succ) {    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++;}

2.3 删除元素Node

2.3.1 删除首字节

// 移除首节点，并返回该节点的元素值public E remove() {    return removeFirst();}public E removeFirst() {    final Node<E> f = first;    if (f == null)        throw new NoSuchElementException();    return unlinkFirst(f);}// 删除首节点fprivate E unlinkFirst(Node<E> f) {    final E element = f.item;    final Node<E> next = f.next;    f.item = null;    f.next = null; // help GC    first = next;    if (next == null) // size=1        last = null;    else        next.prev = null;    size--;    modCount++;    return element;}

2.3.2 删除尾节点

public E removeLast() {    final Node<E> l = last;    if (l == null)        throw new NoSuchElementException();    return unlinkLast(l);}private E unlinkLast(Node<E> l) {    final E element = l.item;    final Node<E> prev = l.prev;    l.item = null;    l.prev = null; // help GC    last = prev;    if (prev == null) // size=1        first = null;    else        prev.next = null;    size--;    modCount++;    return element;}

2.3.3 根据索引删除节点

public E remove(int index) {    checkElementIndex(index);// 检查索引index范围    return unlink(node(index));}E unlink(Node<E> x) {    final E element = x.item;    final Node<E> next = x.next;    final Node<E> prev = x.prev;    if (prev == null) {// x为首节点        first = next;    } else {        prev.next = next;        x.prev = null;    }    if (next == null) {// x为尾节点        last = prev;    } else {        next.prev = prev;        x.next = null;    }    x.item = null;    size--;    modCount++;    return element;}

2.4 获取节点数据

2.4.1 获取首节点数据

// 获取首节点的数据public E getFirst() {    final Node<E> f = first;    if (f == null)        throw new NoSuchElementException();    return f.item;}

2.4.2 获取尾节点数据

// 获取尾节点的数据public E getLast() {    final Node<E> l = last;    if (l == null)        throw new NoSuchElementException();    return l.item;}

2.4.3 根据索引获取节点数据

// 获取索引对应节点的数据public E get(int index) {    checkElementIndex(index);    return node(index).item;}// 类似折半查找Node<E> node(int 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;    }}

三. Fail-Fast机制

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

LinkedList也采用了快速失败的机制，通过记录modCount参数来实现。在面对并发的修改时，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。
它是Java集合的一种错误检测机制。当多个线程对集合进行结构上的改变的操作时，有可能会产生fail-fast机制。记住是有可能，而不是一定。例如：假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出 ConcurrentModificationException 异常，从而产生fail-fast机制。

四. LinkedList遍历比较

package java_src.util;import java.util.Iterator;import java.util.LinkedList;import java.util.ListIterator;import org.junit.Test;import junit.framework.TestCase;public class TestLinkedList extends TestCase {    @Test    public void testLinkedList () {        LinkedList<String> list = new LinkedList<>();        int len = 9000;        for (int i = 0; i < len; i++) {            list.add(String.valueOf(i));        }        System.out.println(len + "个数据: ");        long start = System.currentTimeMillis();        for (int size = list.size(), i = 0; i < size; i++) {            String sta = list.get(i);        }        System.out.println("for循环遍历耗时： " + (System.currentTimeMillis()-start) + "毫秒！");//      System.out.println("for循环遍历直接没反应！ ");        long second = System.currentTimeMillis();        Iterator<String> iterator = list.iterator();        while (iterator.hasNext()) {            String sec = iterator.next();        }        System.out.println("迭代器Iterator遍历耗时： " + (System.currentTimeMillis()-second) + "毫秒！");        long third = System.currentTimeMillis();        for (String i : list) {// 也是Iterator实现的            String thi = i;        }        System.out.println("foreach循环遍历耗时： " + (System.currentTimeMillis()-third) + "毫秒！");        long fourth = System.currentTimeMillis();        ListIterator<String> listIterator = list.listIterator();        while (listIterator.hasNext()) {            String fou = listIterator.next();        }        System.out.println("迭代器ListIterator循环遍历耗时： " + (System.currentTimeMillis()-fourth) + "毫秒！");        long firth = System.currentTimeMillis();        list.forEach(integer -> {            String fir = integer;        });        System.out.println("forEach循环遍历耗时： "+ (System.currentTimeMillis()-firth) + "毫秒！");    }}

运行结果（每次运行都有些差异）:

9000个数据: for循环遍历耗时： 185毫秒！迭代器Iterator遍历耗时： 4毫秒！foreach循环遍历耗时： 7毫秒！迭代器ListIterator循环遍历耗时： 1毫秒！forEach循环遍历耗时： 261毫秒！90000个数据: for循环遍历耗时： 24245毫秒！迭代器Iterator遍历耗时： 10毫秒！foreach循环遍历耗时： 9毫秒！迭代器ListIterator循环遍历耗时： 3毫秒！forEach循环遍历耗时： 122毫秒！900000个数据: for循环遍历直接没反应！ 迭代器Iterator遍历耗时： 26毫秒！foreach循环遍历耗时： 63毫秒！迭代器ListIterator循环遍历耗时： 114毫秒！forEach循环遍历耗时： 295毫秒！9000000个数据: for循环遍历直接没反应！ 迭代器Iterator遍历耗时： 309毫秒！foreach循环遍历耗时： 263毫秒！迭代器ListIterator循环遍历耗时： 294毫秒！forEach循环遍历耗时： 496毫秒！

五. LinkedList与ArrayList比较

1. 顺序插入速度ArrayList会比较快，因为ArrayList是基于数组实现的，数组是事先new好的，只要往指定位置塞一个数据就好了
2. LinkedList则不同，每次顺序插入的时候LinkedList将new一个对象出来，如果对象比较大，那么new的时间势必会长一点，再加上一些引用赋值的操作，所以顺序插入LinkedList必然慢于ArrayList
3. ArrayList的遍历效率会比LinkedList的遍历效率高一些
4. LinkedList做插入、删除的时候，慢在寻址，快在只需要改变前后Node的引用地址
5. ArrayList做插入、删除的时候，慢在数组元素的批量copy，快在寻址
   
   1. 如果确定插入、删除的元素是在前半段，那么就使用LinkedList
   2. 如果确定插入、删除的元素在比较靠后的位置，那么可以考虑使用ArrayList
   3. 如果不能确定插入、删除是在哪儿呢？建议使用LinkedList，
      
      1. 一来LinkedList整体插入、删除的执行效率比较稳定，没有ArrayList这种越往后越快的情况
      2. 二来插入元素的时候，弄得不好ArrayList就要进行一次扩容，而ArrayList底层数组扩容是一个既消耗时间又消耗空间的操作

六. LinkedList源码

基于JDK1.8

package java.util;import java.util.AbstractSequentialList;import java.util.Collection;import java.util.ConcurrentModificationException;import java.util.Deque;import java.util.Iterator;import java.util.List;import java.util.ListIterator;import java.util.NoSuchElementException;import java.util.Objects;public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable {    transient int size = 0;    transient Node<E> first;    transient Node<E> last;    /**     * 创建一个空list     * */    public LinkedList() {    }    public LinkedList(Collection<? extends E> c) {        this();        addAll(c);    }    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 void addFirst(E e) {        linkFirst(e);    }    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++;    }    public boolean add(E e) {        linkLast(e);        return true;    }    public void addLast(E e) {        linkLast(e);    }    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++;    }    public void add(int index, E element) {        checkPositionIndex(index);        if (index == size)            linkLast(element);        else            linkBefore(element, node(index));    }    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++;    }    public boolean addAll(Collection<? extends E> c) {        return addAll(size, c);    }    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;    }    public E remove() {      return removeFirst();    }    public E removeFirst() {      final Node<E> f = first;      if (f == null)          throw new NoSuchElementException();      return unlinkFirst(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;    }    public E removeLast() {      final Node<E> l = last;      if (l == null)          throw new NoSuchElementException();      return unlinkLast(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;    }    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;    }    public E remove(int index) {        checkElementIndex(index);        return unlink(node(index));    }    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;    }    public boolean contains(Object o) {        return indexOf(o) != -1;    }    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;    }    public void clear() {          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++;    }    public E getFirst() {        final Node<E> f = first;        if (f == null)            throw new NoSuchElementException();        return f.item;    }    public E getLast() {        final Node<E> l = last;        if (l == null)            throw new NoSuchElementException();        return l.item;    }    public int size() {        return size;    }    public E get(int index) {        checkElementIndex(index);        return node(index).item;    }    public E set(int index, E element) {        checkElementIndex(index);        Node<E> x = node(index);        E oldVal = x.item;        x.item = element;        return oldVal;    }    private boolean isElementIndex(int index) {        return index >= 0 && index < size;    }    private boolean isPositionIndex(int index) {        return index >= 0 && index <= size;    }    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));    }    Node<E> node(int 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;        }    }    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;    }    public E peek() {        final Node<E> f = first;        return (f == null) ? null : f.item;    }    public E element() {        return getFirst();    }    public E poll() {        final Node<E> f = first;        return (f == null) ? null : unlinkFirst(f);    }    public boolean offer(E e) {        return add(e);    }    public boolean offerFirst(E e) {        addFirst(e);        return true;    }    public boolean offerLast(E e) {        addLast(e);        return true;    }    public E peekFirst() {        final Node<E> f = first;        return (f == null) ? null : f.item;     }    public E peekLast() {        final Node<E> l = last;        return (l == null) ? null : l.item;    }    public E pollFirst() {        final Node<E> f = first;        return (f == null) ? null : unlinkFirst(f);    }    public E pollLast() {        final Node<E> l = last;        return (l == null) ? null : unlinkLast(l);    }    public void push(E e) {        addFirst(e);    }    public E pop() {        return removeFirst();    }    public boolean removeFirstOccurrence(Object o) {        return remove(o);    }    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;    }    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();        }    }    public Iterator<E> descendingIterator() {        return new DescendingIterator();    }    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);        }    }    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;    }    private static final long serialVersionUID = 876323262645176354L;    @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;        }    }    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);    }    @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());    }    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;      }    @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;   }}