Java容器源码解析之——LinkedList

我们直接从源码来分析LinkedList的结构:

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

LinkedList是List和Deque接口的双向链表的实现。实现了所有可选列表操作，并允许包括null值。
LinkedList既然是通过双向链表去实现的，那么它可以被当作堆栈、队列或双端队列进行操作。并且其顺序访问非常高效，而随机访问效率比较低。

LinkedList节点结构:

    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涉及的一些操作链表的变量:

transient int size = 0; //链表中元素的个数
 
transient Node<E> first; //指向链表的头节点
 
transient Node<E> last; //指向链表尾节点

transient 关键字修饰变量表示该值不参与序列化

LinkedList构造函数:

第二种构造函数过程比较复杂，这里重点讲解

1.调用默认构造函数

2.调用addAll(c)方法，最终调用的是addAll(size， c)方法

　　（1）该方法先进行index越界判断，由于index = size所以没有越界

　　（2）将集合c转换成Object数组，判断数组长度是否为0，为0返回false

　　（3） 设置Node<E> pred, succ指针辅助链表操作

　　　　由于index == size，所以设置succ = null, pred = last，相当于从链表尾进行插入操作

　　（4）遍历Object数组，根据数组每个元素生成一个Node节点，并且修改指针将节点插入链表

　　下面假设Object有3个元素，具体展示下3个节点的插入过程:

   初始Node<E> pred, succ; 两个指针为空，且first,last也为空
　　然后执行:

　　　　if (index == size) { //当我们插入位置为链表节点的最后位置时
            succ = null;
            pred = last;
    　　} 

　　接着执行:

   for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null) //pred为空，说明该链表为空，所以设置newNode为第一个节点
                first = newNode; // first指向第一个节点
            else
                pred.next = newNode;
            pred = newNode;
        }

  　　if (succ == null) {
            last = pred;
        }

下面是具体的源码:

 public LinkedList() { //默认构造函数
    }
  public LinkedList(Collection<? extends E> c) { //传入集合参数的构造函数
        this(); //调用默认构造函数
        addAll(c); //方法见下面
    }
 public boolean addAll(Collection<? extends E> c) { //回调addAll(size, c) 是重载方法
        return addAll(size, c); //size值为当前节点个数
    }
 public boolean addAll(int index, Collection<? extends E> c) { //该方法实现再链表index位置插入集合中的所有元素
        checkPositionIndex(index);  //检查index是否越界
 
        Object[] a = c.toArray();　　//将集合c转换成Object数组
        int numNew = a.length;　　//数组长度
        if (numNew == 0)　　//判断数组长度，为0直接返回false
            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) //pred为空，说明该链表为空，所以设置newNode为第一个节点
                first = newNode; // first指向第一个节点
            else
                pred.next = newNode;
            pred = newNode;
        }
 
        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }
 
        size += numNew; //元素个数增加
        modCount++;　　//链表修改次数加一
        return true;
    }
 private void checkPositionIndex(int index) { //检查index是否越界
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

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

public boolean addAll(int index, Collection<? extends E> c)方法还有一种情况，是在index下插入元素，该index != size
我们还是从源码分析:
这里执行else操作, succ = node(index)具体解析在源码注释中体现
具体的节点插入就不再多讲，大家画过图能分析清楚的。

   Node<E> pred, succ; 　　//辅助指针
        if (index == size) { //当我们插入位置为链表节点的最后位置时
            succ = null;
            pred = last;
        } else {
            succ = node(index); //succ指向index节点的后一个位置
            pred = succ.prev;  //pred执行index节点位置
        }
 
  Node<E> node(int index) {
        // assert isElementIndex(index);
 
        if (index < (size >> 1)) {  //判断index是否小于size/2，如果小于从前往后查找，如果大于从后往前查找
            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;
        }
    }

 Deque双端链表操作:

　　插入:

 public void addFirst(E e) { //将指定元素插入此列表的开头
        linkFirst(e);
    }
  private void linkFirst(E e) { //插入列表开头的具体方法
        final Node<E> f = first; //定义一个f指向first队头指针
        final Node<E> newNode = new Node<>(null, e, f); //新建一个newNode，该Node下一个指针指向f(即原列表头位置)
        first = newNode; //fisrt指向newNode节点，也就是指向现在的列表第一个节点
        if (f == null) //如果原链表尾空
            last = newNode; //原链表last也必须指向newNode
        else //链表不为空
            f.prev = newNode; //设置原链表头节点的prev 指向newNode
        size++; //链表元素个数加一
        modCount++; //链表修改次数加一
    }
 public void addLast(E e) { //将指定元素添加到此列表的结尾
        linkLast(e);
    }
  void linkLast(E e) {
        final Node<E> l = last; //定义一个l指向链表最后一个节点位置即last指向的位置
        final Node<E> newNode = new Node<>(l, e, null);//新建一个newNode,该Node的prev执行原链表的最后一个节点
        last = newNode;//原链表的last指针指向newNode
        if (l == null) //如果原链表为空，设置原链表头节点指向newNode
            first = newNode;
        else //如果原链表不为空，设置原链表最后一个节点的next指向newNode
            l.next = newNode;
        size++;
        modCount++;
    }
 public boolean offerFirst(E e) { //在此列表的开头插入指定的元素
        addFirst(e);
        return true;
    }
   public boolean offerLast(E e) { //在此列表末尾插入指定的元素
        addLast(e);
        return true;
    }

　　删除:

  public E removeFirst() { //移除并返回此列表的第一个元素
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f); //删除头节点
    }
 public E removeLast() { //移除并返回此列表的最后一个元素
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }
  public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
  private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        final E element = f.item; //设置一个Element存储要删除节点的值，作为返回值
        final Node<E> next = f.next;// 定义一个next指向第二个节点
        f.item = null; //将头节点值设置为空
        f.next = null; // help GC 断开与头节点的next指针
        first = next; //将头指针指向next节点的位置
        if (next == null) //如果原链表只有一个元素，删除后，需要将last指向null
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }
  public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : 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 void push(E e) { //入栈，操作列表头
        addFirst(e);
    }
public E pop() { //出栈
        return removeFirst();
    }
 public E peek() { //获取头节点元素
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }

队列:

  public boolean offer(E e) { //队尾入队
        return add(e);
    }
public boolean add(E e) {
        linkLast(e);
        return true;
    }
   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 E poll() { //队头出队
        final Node<E> f = first;
        return (f == null) ? null : 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 peek() { //查看队头元素
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }

LinkedList总体介绍都这里了，都是居于链表操作，其他的一些方法大家可以结合源码分析下。