Java 集合：（六） List实现类：LinkedList

一、LinkedList 概述

　　1、对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高。

　　2、LinkedList是一个实现了List接口和Deque接口的双端链表。 

　　　　

　　3、LinkedList底层的链表结构使它支持高效的插入和删除操作，另外它实现了Deque接口，使得LinkedList类也具有 List 的操作以及双端队列和栈的性质。

　　4、LinkedList不是线程安全的，如果想使LinkedList变成线程安全的，可以调用静态类Collections类中的synchronizedList方法：

List list=Collections.synchronizedList(new LinkedList(...));

　　

　　5、LinkedList 的继承结构如下：

　　　　

二、实现的接口

　　　　源码：

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

　　　　（1）实现了 List 接口，具有List的操作方法；

　　　　（2）实现了 Deque 接口，具有双端队列和栈的特性；

　　　　（3）实现了 Cloneable 接口，支持克隆；

　　　　（4）实现了 Serializable 接口，支持序列化；

三、内部结构

　　1、双向链表

　　　　ArrayList是通过数组实现存储，而LinkedList则是通过链表来存储数据，而且他实现的是一个双向链表，简单的说一下什么是双向链表。

　　　　双向链表是数据结构的一种形式，他的每个节点维护两个指针，prev指向上一个节点，next指向下一个节点。

　　　　这种结构有什么特点呢？他可以实现双向遍历，这使得在链表中的数据读取变得非常灵活自由。

　　　　同时，LinkedList中维护了两个指针，一个指向头部，一个指向尾部。维护这两个指针后，可以使得元素从头部插入，也可以使元素从尾部插入。

　　　　基于方式，用户很容易就能实现FIFO(队列)，LIFO(栈)等效果。那么下面我们来看一下源码中的具体实现。

　　2、内部结构分析

　　　　　　如图所示：

　　　　　　   

　　　　LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基

本结构。

　　　　Node除了保存数据，还定义了两个变量：

　　　　　　① prev变量记录前一个元素的位置 

　　　　　　② next变量记录下一个元素的位置

　　　　看完了图之后，我们再看LinkedList类中的一个内部私有类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 类中，还有几个成员变量如下：

// list 的长度
transient int size = 0;

// 链表头结点
transient Node<E> first;

// 链表尾结点
transient Node<E> last;

//序列化标记
private static final long serialVersionUID = 876323262645176354L;

五、构造器

　　　　LinkedList 有两个构造器，如下：

　　　　（1）无参构造：

    public LinkedList() {
    }

　　　　（2）用已有的集合创建链表的构造方法：

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

　　　　注意：由于链表的容量可以一直增加，因此没有指定容量的构造器。

　　　　第一个为无参构造器。

　　　　第二个为使用指定集合的集合构造，并调用 addAll() 方法，继续跟进该方法，代码如下：

public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}
    
public boolean addAll(int index, Collection<? extends E> c) {
    //1:检查index范围是否在size之内
    checkPositionIndex(index);
    
    //2:toArray()方法把集合的数据存到对象数组中
    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;
        
        
    //3：获取当前链表的前驱和后继结点，得到插入位置的前驱节点和后继节点
    Node<E> pred, succ;
    //如果插入位置为尾部，前驱节点为last，后继节点为null
    if (index == size) { 
        succ = null;
        pred = last;
    } 
    //若非尾结点，获取指定位置的结点，调用node()方法得到后继节点，再得到前驱节点,
    else { 
        succ = node(index);  //获取当前节点
        pred = succ.prev;    //获取当前节点前驱节点
    }
    
    // 4：循环将数组中的元素插入到链表
    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;
    }
    
    //如果插入位置在尾部，重置last节点
    // 若插入到末尾，则数组中的最后一个元素就是尾结点
    if (succ == null) {
        last = pred;
    } 
    
    //否则，将插入的链表与先前链表连接起来
    else {
        // 若插入到指定位置，将数组中最后一个元素与下一个位置关联起来
        pred.next = succ;
        succ.prev = pred;
    }
    size += numNew;
    modCount++;
    return true;
}

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

private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
}

　　上面可以看出addAll方法通常包括下面四个步骤：

1. 检查index范围是否在size之内；

2. toArray()方法把集合的数据存到对象数组中；

3. 得到插入位置的前驱和后继节点；

4. 遍历数据，将数据插入到指定位置，如果没有在尾部，把原来数据链起来；

　　其中 node(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;
        }
    }

　　　　该方法通过遍历链表获取指定的元素。

　　　　值得注意的是，该方法并非直接从头到尾遍历整个链表，而是先判断下标的位置，若在前一半则从前往后遍历；否则就从后往前遍历。这样能减少遍历结点的个数。

 

　　　　因为链表的内存空间是非连续的，所以不支持随机访问（下标访问）。所以，查询某个结点是通过遍历整个链表来实现的。

 

六、常用方法

　　1、新增结点方法【尾插法】：add()，addLast()，offer()，offerLast()

　　　　源码分析：

    public boolean add(E e) {
        linkLast(e);
        return true;
    }
    public void addLast(E e) {
        linkLast(e);
    }
    public boolean offer(E e) {
        return add(e);
    }
    public boolean offerLast(E e) {
        addLast(e);
        return true;
    }

　　可以看到他们都是调用了同一个方法 linkLast(e) 实现的，如下：

    /**
     * Links e as last element.
     */
    void linkLast(E e) {
        final Node<E> l = last;
        // 创建一个节点，将prev指针指向链表的尾节点。
        final Node<E> newNode = new Node<>(l, e, null); 

        // 将last指针指向新创建的这个节点。        
        last = newNode;
        
        if (l == null)
            // 如果当前链表为空，那么将头指针也指向这个节点。
            first = newNode;

        else
            // 若链表不为空，将新结点插入到链表尾部
            // 将链表的尾节点的next指针指向新建的节点，这样就完整的实现了在链表尾部添加一个元素的功能。
            l.next = newNode;
        size++;
        modCount++;
    }

　　　　该操作就是将指定的结点添加到链表末尾。

　　2、新增节点【头插法】：addFirst()，offerFirst()

　　　　源码:

    public void addFirst(E e) {
        linkFirst(e);
    }
    public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

　　　　可以看到他们都是调用了同一个方法 linkFirst(e) 实现的，如下：

    /**
     * Links e as first element.
     */
    private void linkFirst(E e) {
        final Node<E> f = first;
        // 创建一个新元素，将元素的next指针指向当前的头结点
        final Node<E> newNode = new Node<>(null, e, f);
         // 将头指针指向这个节点。
        first = newNode;
        if (f == null)
            // 如果当前节点为空，则把尾指针指向这个节点。
            last = newNode;
        else
            // 将当前头结点的prev指针指向此结点。
            f.prev = newNode;
        size++;
        modCount++;
    }

　　　　这段代码就是实现将元素添加的链表头部。

　　3、新增节点【指定位置插入】：add(int index, E element)

　　　　源码：

    public void add(int index, E element) {
        checkPositionIndex(index);

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

　　　　在这里分了两种情况：

　　　　① 如果刚好到尾部，直接在尾部插入；

　　　　② 如果没有在尾部，在非null节点之前插入元素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++;
    }
    
    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++;
    }

　　4、设置值：set(int index, E element)

　　　　源码：

    public E set(int index, E element) {
        //索引检查
        checkElementIndex(index);
        
        //获取该索引的元素
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }

　　5、查找值：get(int index)

　　　　源码：

    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

　　　　可以看到，这里还是调用了上面的 node() 方法进行查找的。

　　6、获取头节点：

　　　　源码：

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

　　　　区别：

　　　　getFirst(),element(),peek(),peekFirst() 这四个获取头结点方法的区别在于对链表为空时的处理，是抛出异常还是返回null，

　　　　其中getFirst() 和element() 方法将会在链表为空时，抛出异常；element()方法的内部就是使用getFirst()实现的。它们会在链表为空时，抛出NoSuchElementException；

　　　　而 peek() 和 peekFirst() 方法在链表为空时会返回空；

　　7、获取尾结点

　　　　源码：

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

　　　　两者区别： getLast() 方法在链表为空时，会抛出NoSuchElementException，而peekLast() 则不会，只是会返回 null。

　　8、根据对象得到索引的方法

　　　　int indexOf(Object o)： 从头遍历找

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

　　　　int lastIndexOf(Object o)： 从尾遍历找

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

　　9、检查链表是否包含某对象的方法：contains()

　　　　源码：

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

　　10、删除头节点方法：remove() ,removeFirst(),pop()，poll()，pollFirst()

　　　　源码：

    public E remove() {
        return removeFirst();
    }
    
    public E pop() {
        return removeFirst();
    }
    
    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }
    
    public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
    public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

　　　　本质上都是调用了 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;
    }

　　11、删除尾节点方法：removeLast(),pollLast()

　　　　源码：

    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }
    
    public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }

　　　　区别： removeLast()在链表为空时将抛出NoSuchElementException，而pollLast()方法返回null。

　　　　本质上都是调用了 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;
    }

　　12、删除指定元素：remove(Object o) & 删除指定位置的元素：remove(int index)

　　　　源码：

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

　　　　当删除指定对象时，只需调用remove(Object o)即可，不过该方法一次只会删除一个匹配的对象，如果删除了匹配对象，返回true，否则false。

　　　　本质上还是调用了 unlink(Node<E> 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;
    }

　　13、序列化方法：writeObject(java.io.ObjectOutputStream s)

　　　　源码：

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

　　14、反序列化方法：readObject(java.io.ObjectInputStream s)

　　　　源码：

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

七、作为其他数据结构

　　1、FIFO(队列)实现原理

　　　　队列的原理就是每次都从链表尾部添加元素，从链表头部获取元素，就像生活中的排队叫号，总是有个先来后到。

　　　　源码：

// 队列尾部添加一个元素，建议使用这个，约定俗成吧。
publicboolean offer(E e){
    return add(e);
}

// 队列尾部添加一个元素
publicboolean offerLast(E e){
    addLast(e);
    return    true;
}

// offer和offerLast底层调用的都是linkLast这个方法，顾名思义就是将元素添加到链表尾部。
void linkLast(E e){
    finalNode<E> l =last;
    
    // 创建一个节点，将prev指针指向链表的尾节点。
    finalNode<E> newNode =newNode<>(l, e,null);
    
    // 将last指针指向新创建的这个节点。
    last= newNode;
    
    if(l ==null)
        // 如果当前链表为空，那么将头指针也指向这个节点。
        first = newNode;
    else
        // 将链表的尾节点的next指针指向新建的节点，这样就完整的实现了在链表尾部添加一个元素的功能。
        l.next= newNode;
        
    size++;
    modCount++;
}

// 在链表头部删除一个元素，建议用这个
public E poll(){
    final    Node<E> f = first;
    return(f ==null)?null: unlinkFirst(f);
}
// 在链表头部删除一个元素
public E pollFirst(){
    final    Node<E> f = first;
    return(f ==null)?null: unlinkFirst(f);
}

// poll和pollFirst底层调用的就是这个方法，将链表的头元素删除。
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 peek(){
    final    Node<E> f = first;
    return(f ==null)?null: f.item;
}

　　　　更准确来说，链表是一个双端链表的结构，可以在头尾都进行操作节点。

　　2、LIFO(栈)实现原理：

　　　　栈的原理是每次从头部添加元素，也从头部获取元素，那么后进入的元素反而最先出来。就像我们平时叠盘子，洗好了就一个一个往上放，然后要用了就从上往下一个一个拿。

　　　　源码：

// 在链表的头部添加一个元素
publicvoid push(E e){
    addFirst(e);
}

// addFirst调用的就是linkFirst，这段代码就是实现将元素添加的链表头部。
private void linkFirst(E e){
    final    Node<E> f = first;
    // 创建一个新元素，将元素的next指针指向当前的头结点
    final    Node<E> newNode =newNode<>(null, e, f);
    // 将头指针指向这个节点。
    first = newNode;
    if(f ==null)
        // 如果当前节点为空，则把尾指针指向这个节点。
        last= newNode;
    else
        // 将当前头结点的prev指针指向此结点。
        f.prev = newNode;
    size++;
    modCount++;
}

// 弹出顶部结点。
public E pop(){
    return removeFirst();
}

// removeFirst调用的就是unlinkFirst，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;
}

// 获取顶部结点，但是不删除
public E peek(){
    final    Node<E> f = first;
    return(f ==null)?null: f.item;
}

八、迭代器相关

　　LinkedList的迭代器实现有两个，一个是实现了Iterator接口的DescendingIterator，另一个则是实现了ListIterator接口的ListItr。

　　1、ListItr

　　　　源码：

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;

    // 实例化的时候，将next指针指向指定位置的元素
    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();
    }
}

　　2、DescendingIterator

　　　　DescendingIterator迭代器实现的是对链表从尾部向头部遍历的功能，他复用里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();
        }
    }

九、不同版本的 LinkedList

　　在LinkedList 中 JDK1.6 之前为双向循环链表，JDK1.7 取消了循环，采用双向链表。

　　1、双向链表

　　　　双向链表属于链表的一种，也叫双链表双向即是说它的链接方向是双向的，它由若干个节点组成，每个节点都包含下一个节点和上一个节点的指针，所以从双向链表的任意节点开始，都能很方便访问他的前驱结点和后继节点。

　　　　

　　2、双向链表特点

• • 创建双链表时无需指定链表的长度。
  • 比起单链表，双链表需要多一个指针用于指向前驱节点，所以需要存储空间比单链表多一点。
  • 双链表的插入和删除需要同时维护 next 和 prev 两个指针。
  • 双链表中的元素访问需要通过顺序访问，即要通过遍历的方式来寻找元素。

　　3、双向循环链表

　　　　前面的双向链表的 head 节点和链尾没有连接关系，所以如果要访问最后一个节点的话需要从头开始遍历，直到最后一个节点。在双向链表基础上改进一下，把 header 节点的 prev 指针指向最后一个节点，而最后一个节点的 next 指针指向 header 节点，于是便构成双向循环链表。

　　　　

 　　　　　　

 　　　　　　更多链表操作：https://juejin.cn/post/6844903648154271757#heading-0

 　　4、JDK6 

　　　　在JDK 1.7之前（此处使用JDK1.6来举例），LinkedList是通过headerEntry实现的一个循环链表的。先初始化一个空的Entry，用来做header，然后首尾相连，形成一个循环链表：

privatetransient Entry<E>header =new Entry<E>(null,null,null);

public LinkedList() {header.next =header.previous =header; }

　　　　

　　　　在LinkedList中提供了两个基本属性size、header。

private transient Entry<E> header = new Entry<E>(null, null, null);
private transient int size = 0;

• 其中size表示的LinkedList的大小，header表示链表的表头，Entry为节点对象。

private static class Entry<E> {
        E element;        //元素节点
        Entry<E> next;    //下一个元素
        Entry<E> previous;  //上一个元素
 
        Entry(E element, Entry<E> next, Entry<E> previous) {
            this.element = element;
            this.next = next;
            this.previous = previous;
        }
}

• 上面为Entry对象的源代码，Entry为LinkedList的内部类，它定义了存储的元素。该元素的前一个元素、后一个元素，这是典型的双向链表定义方式。

　　每次添加/删除元素都是默认在链尾操作。对应此处，就是在header前面操作，因为遍历是next方向的，所以在header前面操作，就相当于在链表尾操作。

　　如下面的插入操作addBefore以及图示，如果插入obj_3，只需要修改header.previous和obj_2.next指向obj_3即可。

　　

private Entry<E> addBefore(E e, Entry<E> entry) {
        //利用Entry构造函数构建一个新节点 newEntry，
        Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
        //修改newEntry的前后节点的引用，确保其链表的引用关系是正确的
        newEntry.previous.next = newEntry;
        newEntry.next.previous = newEntry;
        //容量+1
        size++;
        //修改次数+1
        modCount++;
        return newEntry;
    }

• 在addBefore方法中无非就是做了这件事：构建一个新节点newEntry，然后修改其前后的引用。

　　5、JDK7

　　　　在JDK 1.7，1.6的headerEntry循环链表被替换成了first和last组成的非循环链表。

    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;

• 在初始化的时候，不用去new一个Entry。

　　　　

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

• 在插入/删除的时候，也是默认在链尾操作。把插入的obj当成newLast，挂在oldLast的后面。另外还要先判断first是否为空，如果为空则first = obj。

　　

　　如下面的插入方法linkLast，在尾部操作，只需要把obj_3.next指向obj_4即可。

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

其中

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

　　6、【1.6-header循环链表】 V.S 【1.7-first/last非循环链表】

　　　　JDK 1.7中的first/last对比以前的header有下面几个好处：

　　　　（1） first / last有更清晰的链头、链尾概念，代码看起来更容易明白。

　　　　（2）first / last方式能节省new一个headerEntry。（实例化headerEntry是为了让后面的方法更加统一，否则会多很多header的空校验）

　　　　（3）在链头/尾进行插入/删除操作，first /last方式更加快捷。

　　　　插入/删除操作按照位置，分为两种情况：中间 和 两头。

　　　　在中间插入/删除，两者都是一样，先遍历找到index，然后修改链表index处两头的指针。
　　　　在两头，对于循环链表来说，由于首尾相连，还是需要处理两头的指针。而非循环链表只需要处理一边first.previous/last.next，所以理论上非循环链表更高效。　　　　　　恰恰在两头(链头/链尾) 操作是最普遍的

　　　　（对于遍历来说，两者都是链表指针循环，所以遍历效率是一样的。）

十、线程安全性

　　线程安全的概念不再赘述。分析以下场景：

　　若有线程 T1 对 LinkedList 进行遍历，同时线程 T2 对其进行结构性修改。

 

　　对 LinkedList 的遍历是通过 listIterator(index) 方法实现的，如下：

    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 E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();


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


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


        // ...
        
        // 是否有其他线程对当前对象进行结构修改
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
}

　　该类的 next(), add(e) 等方法在执行时会检测 modCount 与创建时是否一致（checkForComodification() 方法），从而判断是否有其他线程对该对象进行了结构修改，若有则抛出 ConcurrentModificationException 异常。

 

　　因此，LinkedList 是线程不安全的。

 

十一、总结

　　1、LinkedList 内部是【双向链表】，同时实现了 List  接口 和 Deque 接口，因此也具备 List、双端队列和栈的性质。

　　2、线程不安全。