LinkedList源码解析

前言:继上篇，ArrayList和LinkedList算是一对兄弟，虽然它们都实现了List接口，但是它们的本质却相差很大。

目录:
一. 概述
二. 源码分析
    (1) LinkedList初始化
    (2) LinkedList增加元素操作【增】
    (3) LinkedList的删除元素操作【删】
    (4) LinkedList的替换元素操作【改】
    (5) LinkedList的获取元素操作【查】
三. 与ArrayList的区别 
    (1)相同点
    (2)不同点
四. 总结

一. 概述

（1）LinkedList是基于双向链表实现的，链表具有插入和删除效率高而改查效率低的特点。
（2）因为使用链表的原因，所以不存在容量不足的问题，没有扩容机制。
（3）LinkedList继承了AbstractSequentialList，而AbstractSequentialList为顺序访问的数据存储结构提供了一个骨架类实现。实现了Deque<E>接口, Deque是Queue的子接口,Queue是一种队列形式,而Deque是双向队列,它支持从两个端点方向检索和插入元素。

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

（4） LinkedList允许元素为null，并且是线程不安全的。

二. 源码分析

(1) LinkedList初始化

构造方法

//元素个数
transient int size = 0;
//链表头节点
transient Node<E> first;
//链表尾节点
transient Node<E> last;
//无参构造器
public LinkedList() {
}
//有参构造器，参数为LinkedList集合，把集合c里的元素插入到链表中
public LinkedList(Collection<? extends E> c) {
     this();
     //插入集合方法后面分析
     addAll(c);
}

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

从上面可以看出，LinkedList底层是基于Node实现的，是一个双向链表

(2) LinkedList增加元素操作【增】

1.添加单个元素到l链表末尾，add(E e)方法

public boolean add(E e) {
        linkLast(e);
        return true;
}
//直接调用添加末尾的方法
void linkLast(E e) {
        //尾节点
        final Node<E> l = last;
        //构建新的节点,之前的尾节点为前一个节点，null为后一个节点
        final Node<E> newNode = new Node<>(l, e, null);
        //设置新的节点为尾节点
        last = newNode;
        //如果l为null(即原来链表为空链表),需要额外说明新的节点为首节点,否则就设置新的节点为l的下一节点
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;//链表的大小+1
        modCount++;        
}

 2.添加单个元素到指定位置，add(int index, E element)方法

public void add(int index, E element) {
        //校验index有效性[0,size]
        checkPositionIndex(index);
        //如果index等于size,说明添加到链表末尾，直接调用添加末尾的方法
        if (index == size)
            linkLast(element);
        else 
            //否则调用添加到 index位置的前一个节点   
            linkBefore(element, node(index));
}

void linkBefore(E e, Node<E> succ) {
        //记下前一个节点为当前节点的上一个节点
        final Node<E> pred = succ.prev;
        //构建新的节点，新的节点前一个节点为pred，后一节点为原index位置的节点
        final Node<E> newNode = new Node<>(pred, e, succ);
        //同步更新原index位置的节点为前节点为新的节点
        succ.prev = newNode;
        //同时判断pred是否为空，为空的话说明首节点就是新的节点，否则同步更新pred.next为新的节点
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
}

//这个方法的思路是 判断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;
        }
}

这里要总结一下，作为链表的插入、后续要讲的删除操作，直观上是破坏了原有的结构，无论是插入在首位置、中间位置、还是末位置都要重新连接起来。即新的节点要主动关联前后节点，前后节点也要主动关联新的节点。

3.添加集合到数组末尾，addAll(Collection<? Extends E>   c)方法

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

public boolean addAll(int index, Collection<? extends E> c) {
        //校验index有效性[0,size]
        checkPositionIndex(index);
        
        //将集合转化为数组
        Object[] a = c.toArray();
        int numNew = a.length;
        //如果是空数组，返回false
        if (numNew == 0)
            return false;
        //定义index位置的前置节点、后置节点
        Node<E> pred, succ;
        if (index == size) {
             //如果index为链表的长度，则说明批量添加到链表的末尾,前置节点为最后一个元素,后置节点为null
            succ = null;
            pred = last;
        } else {
            //后置节点为修改前index位置的元素，前置节点为修改前index位置的元素的前一个节点
            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) {
            //判断succ是否为空，为空的话集合的最后一个元素就是尾节点
            last = pred;
        } else {
            //否则succ链接到集合的最后一个元素
            pred.next = succ;
            succ.prev = pred;
        }
        //链表长度增加集合的长度
        size += numNew;
        modCount++;
        return true;
}

4.添加集合到指定位置，addAll(int index，Collection<? Extends E>   c)方法

上面已对该方法分析。

  (3) LinkedList的删除元素操作【删】

1.移除指定位置的元素，remove(int index)方法

public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
}

//单从方法名字可以看出，意为失连。即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) {
            //如果前置结点为null,则说明删除的就是第一个结点，头结点就是next
            first = next;
        } else {
            //否则，前置结点的后结点就是next
            prev.next = next;
            //删除的节点的前置结点置空    
            x.prev = null;
        }

        if (next == null) {
            //如果后置结点为null，则说明删除的就是最后一个节点,尾节点就是prev
            last = prev;
        } else {
            //否则，后置结点的前结点就是prev
            next.prev = prev;
            //删除的节点的后置结点置空
            x.next = null;
        }
        //删除的元素置空    
        x.item = null;
        //链表的长度-1
        size--;
        modCount++;
        return element;
}

2.移除指定的元素，remove(Object o)方法

public boolean remove(Object o) {
        if (o == null) {
            //遍历链表，调用unlink(x)
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            //遍历链表,调用unlink(x)
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
}

3.清空集合，clear()方法

public void clear() {
        //遍历链表，将元素的前后节点、自身都设为null
        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++;
}

  (4) LinkedList的替换元素操作【改】

1.替换指定位置的元素，set(int index， E element)方法

public E set(int index, E element) {
        //检查索引有效性
        checkElementIndex(index);
        //获取index位置的元素
        Node<E> x = node(index);
        //记下当前节点的元素
        E oldVal = x.item;
        //将新值覆盖旧值
        x.item = element;
        //返回旧的值
        return oldVal;
}

  (5) LinkedList的获取元素操作【查】

获取元素操作大致归纳为获取元素，判断集合是否包含某个元素。
1.获取指定位置的元素，get(int index)方法

public E get(int index) {
        //检查索引有效性
        checkElementIndex(index);
        //调用node(index)方法，前面已分析过
        return node(index).item;
}

2.判断集合是否含有某个元素，contains(Object o)方法

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

三. 与ArrayList的区别

  (1) 相同点

1.两个都是线程不安全的
2.两个都允许元素为null
3.两个都是实现了List接口

 (2) 不同点

1.LinkedList是基于双向链表实现的，继承了AbstractSequentialList，便于顺序访问。
   ArrayList是基于动态数组实现的，继承了AbstractList，支持随机访问。
2.Linked没有扩容机制。
3.LinkedList在add()、remove()操作有这很好的性能，而ArrayList在get()有较好的性能

四. 总结

(1).在遍历LinkedList，尽量别用for循环遍历，特别是在数据量很大的时候。可以用foreach，或者iterator来遍历。