LinkedList源码解析

LinkedList源码解析

简要概述

LinkedList类是List接口的实现类，它是一个集合，可以根据索引来随机的访问集合中的元素，还实现了Deque接口，它还是一个队列，可以被当成双端队列来使用。虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，ArrayList的底层是通过一个动态的Object[]数组来实现的，而LinkedList的底层是通过链表来实现的，因此它的随机访问速度是比较差的，但是它的删除，插入操作会很快。

• LinkedList是基于双向循环链表实现的，除了可以当做链表来操作外，它还可以当做栈、队列和双端队列来使用。
• LinkedList同样是非线程安全的，只在单线程下适合使用。
• LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆。

什么是双向循环链表？

从名字就可以看出，双向链表是包含两个指针的，pre指向前一个节点，next指向后一个节点，但是第一个节点head的pre指向null，最后一个节点的tail指向null。

源码解析

LinkedList 提供了以下三个成员变量。size，first，last，其中 size 为 LinkedList 的大小，first 和 last 分别为链表的头结点和尾节点。Node 为节点对象。

public class LinkedList<E>extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
 
    transient int size = 0;   //LinkedList中存放的元素个数
 
    transient Node<E> first;  //头节点
    
    transient Node<E> last;   //尾节点
 
    //构造方法，创建一个空的列表
    public LinkedList() {
}

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

构造方法实现

add方法（不指定元素位置

public boolean add(E e) {
    linkLast(e);
    return true;
}

其中调用了linkLast（）方法！

void linkLast(E e) {
    final Node<E> l = last;
    //新创建节点， l 前继结点, e 新创建节点, null后继节点
    final Node<E> newNode = new Node<>(l, e, null);
    //使新节点成为尾节点
    last = newNode;
    //如果是空，就让新节点为头结点
    //如果不为空，就让原尾节点的后继节点是newNode
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

add方法（指定元素位置

 public void add(int index, E element) {
 //判断参数合法性
        checkPositionIndex(index);
//判断index是不是尾部节点
        if (index == size)
            linkLast(element);
        else
        //element要插入节点
        //node（index）原位置节点
            linkBefore(element, node(index));
    }

其中也调用了linkLast（E 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;
        //原index的前继节点pred
        final Node<E> pred = succ.prev;
        //newNode=pred<--e-->succ
        final Node<E> newNode = new Node<>(pred, e, succ);
        //修改原succ节点的前继节点是newNode
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
          //修改pred节点的指针，指向newNode节点
            pred.next = newNode;
        size++;
        modCount++;
    }

get方法

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

private void checkElementIndex(int index) {
//判断参数合法性
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

//获取index位置的元素节点
Node<E> node(int index) {
    // assert isElementIndex(index);

        //如果index小于（元素size的二分之一）
        //从前往后找
    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;
    }
}

remove方法

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

//unlink（）是解开链接方法

E unlink(Node<E> x) {
    // assert x != null;
    //x 要删除节点
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;
    //如果删除节点的前继节点==null

    if (prev == null) {
    //头部指向x删除节点的后继节点
        first = next;
    } else {
    //删除元素的前继节点-->删除元素的后继节点
        prev.next = next;
        //将其置空，方便GC回收
        x.prev = null;
    }
    //（prev）<--X-->（next）
//删除节点的后继节点==null
    if (next == null) {
    //尾部指向删除节点的prev
        last = prev;
    } else {
    //（prev）<--(next)
    //x-->（next）null
    //删除节点的后继节点，指向删除节点的前继节点
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

remove（指定下标位置删除

 public E remove(int index) {
        checkElementIndex(index);
        //获取node（index）位置的元素
        return unlink(node(index));
    }

重复方法，不过多赘述！

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

pop方法

public E pop() {
    return removeFirst();
}

public E removeFirst() {
    final Node<E> f = first;
    //如果头结点为空
    if (f == null)
        throw new NoSuchElementException();
    return 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;
    }