java 中LinkedList详解，附带一部分源码和ArrayList的比较

数据结构一般分为两大类： 线性数据结构如线性表、栈、队列、串、数组、和文件 n个元素的有限序列，除了第一个元素，其他元素只有唯一的一个前驱，除了最后一个元素，其他元素只有一个唯一的后继，所有数据在同一个线性表中必须是相同的数据类型。
非线性数据结构 如树和图

下面这幅图表现的是我近期内要学习的一些集合类

ArrayList 和LinkedList的区别：
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 注意的是LinkedList是双向链表，但是在JDK 1.7中是不循环的双向链表，在以前的版本中是双向循环链表
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。查找操作 ArrayList好
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 增删 LinedList 好
4. LinkedList需要更多的内存，因为ArrayList的每个索引的位置是实际的数据，而LinkedList中的每个节点中存储的是实际的数据和前后节点的位置。但是有时ArrayList在容量扩展的时候也会浪费掉很多内存。

LinkedList 有一个私有的内部类 Node，其也只有一个构造方法，里面有三个参数， 指向下一个节点的next， 携带的对象 item， 指向上一个节点的 prev

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

第一： LinkedList的函数声明：LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList 实现 List 接口，能对它进行队列操作。
LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
LinkedList 是非同步的。即是意味着是线程不安全的

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

第二： LinkedList的构造方法， 可以看到其有两种构造方法，第一个是空的，为什么是空的呢？那它是怎样创建一个List的，查阅源码，我们可以看到，忽略了一些代码，它们是声明初始LinkedList成员变量的，就是下面的三个属性：

    transient int size = 0;
    transient Node<E> first;
    transient Node<E> last;

而且，我们发现它的内部类Node 是被定义为Static的，也就意味着它在类被加载的时候就已经被调用了， 构建顺序为首先在工程加载时初始静态代码；new一个对象时，先执行父类的非静态代码初始父类成员变量，然后执行父类的构造方法，接着初始子类的成员变量，最后才执行子类的构造方法，从而完成对象的创建。

无参构造为空实现。有参构造传入Collection对象，将对象转为数组，并按遍历顺序将数组首尾相连，全局变量first和last分别指向这个链表的第一个和最后一个，修改prev、next指向与原LinkedList对象链接。最终形成新链表。

private static class Node<E> {}

    //构造函数
    public LinkedList() {
    }
   // 将一个集合构建
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
public boolean addAll(Collection<? extends E> c) {  
    return addAll(size, c);  
}  
// 在给定的位置插入一个集合中的所有对象 ，注意的是插入的对象**位于index定位的对象的前方**
public boolean addAll(int index, Collection<? extends E> c) {  
    // 检查传入的索引值是否在合理范围内  index》=0  && index《=size
    checkPositionIndex(index);  
    // 将给定的Collection对象转为Object数组  
    Object[] a = c.toArray();  
    int numNew = a.length;  
    // 数组为空的话，直接返回false  
    if (numNew == 0)  
        return false;  
    // 数组不为空  
    Node<E> pred, succ;  
    if (index == size) {  
        // index = size = 0 链表为空的时候进入这个条件。
        succ = null;  
        pred = last;  
    } else {  
        // 链表非空时调用，node方法返回给定索引位置的节点对象  
        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; // 将当前链表最后一个节点赋值给last  
    } else {  
        // 链表非空时，将断开的部分连接上  
        pred.next = succ;  
        succ.prev = pred;  
    }  
    // 记录当前节点个数  
    size += numNew;  
    modCount++;  
    return true;  
} 

// 根据索引定位对象所在的位置，从代码中我们可以看到其做了优化，只需要查找一半的元素就可以定位到，这是因为，它把下标和集合的长度size/2进行了比较，如果下标位于0--size/2 就从前往后查找， 如果坐标位于size/2---size 就从后往前查找，这也是双向链表的优势。
    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;
        }
    }

注意的第一点： 根据索引定位对象所在的位置，从代码中我们可以看到其做了优化，只需要查找一半的元素就可以定位到,大大提升了效率，因此在get(index)方法中也使用了此种方法，原因请看上面关于Node(index)的分析。
注意的第二点：在给定的位置插入一个集合中的所有对象 或者在给定位置插入一个对象，注意的是插入的对象位于给定index定位的对象的前方 而不是后方 ，在add(index,Object)方法中也有体现,如下：是linkBefore(.., ..)

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

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

第三：因为LinkedList是链表，自身维护的是Node节点，里面还定义了几个属性 first last ，因此它多出来一些方法方便大家快捷使用，比如：
addfirst, addLast, getFirst, getlast, 等，但是和一般的增加删除方式是一致的，都是关于链表的增删修改， 需要注意的是在删除的时候，要将删除节点的 prev，next，Item全部设置为null以便于垃圾回收