LinkedList源码解析（一）

一下分析皆以jdk1.8为准。

继承结构

首先我们来看一下LinkedList的继承结构类图：

可以看出LinkedList实现了List，Cloneable，Serializable，Deque接口。LinkedList是collections集合中功能最丰富的一个类，它不仅仅是一个List，还是一个队列，还是一个双向队列，还可以当栈来使用。LInkedlist是链表结构，内部通过一个一个相互链接的节点Node来存储数据，每个节点都有一个对与上一个节点和下一个节点的引用。所以对于频繁的插入删除操作比较方便（只要调整上下节点的引用），对于遍历，搜索查询效率比较低（需要从第一个节点一个个遍历）。

我们来看看LinkedList的基本数据成员。

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

LinkedList采用节点Node来存储实际数据，Node的结构非常简单

                 private static class Node {        E item;        Node next; //下一个节点        Node prev; //上一个节点        Node(Node prev, E element, Node next) {            this.item = element;            this.next = next;            this.prev = prev;        }    }       

无参构造函数

//创建一个空的linkedList，first和last都为nullpublic LinkedList() {}

有参构造函数LinkedList(Collection<?extends E> c)

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

// index参数指定collection中插入的第一个元素的位置public boolean addAll(int index, Collection<? extends E> c) {        checkPositionIndex(index);  //检查索引范围是否合法：是否在0到size之间        Object[] a = c.toArray();  //将c转换为对象数组        int numNew = a.length;        if (numNew == 0)            return false;        Node pred, succ;  //succ为插入位置处的节点，pred为插入位置的前一个节点        if (index == size) { //从末尾插入，构造函数传入index=size=0;            succ = null;            pred = last;        } else {            //从中间插入            succ = node(index);            pred = succ.prev;        }        //双向链表插入        for (Object o : a) {            @SuppressWarnings("unchecked") E e = (E) o;            Node newNode = new Node<>(pred, e, null);            if (pred == null)                first = newNode;            else                pred.next = newNode;            pred = newNode;        }        if (succ == null) {  //从末尾插入，将当前链表的最后一个节点赋值给last            last = pred;        } else {            //从中间插入，将断开的部分重新链接上。            pred.next = succ;            succ.prev = pred;        }        size += numNew;          modCount++;        return true;    }

从末尾添加元素add(E e)

     public boolean add(E e) {        linkLast(e);        return true;    }    //从list末尾添加元素e    void linkLast(E e) {        final Node l = last;  //将原来的末尾节点赋值给l        final Node newNode = new Node<>(l, e, null);构造新节点，新节点的前置为原先的last        last = newNode; //新节点设置为末尾节点        if (l == null)  //list为空            first = newNode;        else            l.next = newNode;        size++;        modCount++;    }

在指定位置添加节点add(int index,E element)

    public void add(int index, E element) {        checkPositionIndex(index); //检查索引范围是否在0到size之间        if (index == size)  //从末尾添加            linkLast(element);        else                //从中间位置添加            linkBefore(element, node(index));    }    void linkBefore(E e, Node succ) {        // assert succ != null;        final Node pred = succ.prev;        final Node newNode = new Node<>(pred, e, succ);        succ.prev = newNode;        if (pred == null)            first = newNode;        else            pred.next = newNode;        size++;        modCount++;    }

 Node node(int index) {      // assert isElementIndex(index);    if (index < (size >> 1)) {  //如果index小于size的一半，从前往后遍历        Node x = first;        for (int i = 0; i < index; i++)            x = x.next;        return x;    } else {                   //如果index大于等于size的一般，从后往前遍历。不需要从头到尾遍历一遍，提高效率        Node x = last;        for (int i = size - 1; i > index; i--)            x = x.prev;        return x;    }}

其余的一些添加，删除也是对于链表的操作，改变节点的前后引用。

LinkedList基于双向线性链表，内部表示就是一个一个相互链接的节点Node。而且它不像ArrayList,arraylist内部用数组来存储数据，还有扩容的问题。linkedList没有需要扩容，需要一个节点一个节点的链接下去。当然linkedList消耗的内存比ArrayList大一些。