LinkedList类源码阅读

一、简介

LinkedList位于java.util包中，也是我们比较常见的集合对象。

• LinkedList底层是基于双向链表实现的，适合于插入和删除比较多的场景，查询速度相对来说比较慢，由于需要沿着链表挨个查找。

• 防止意外对列表的非同步访问: List list = Collections.synchronizedList(new LinkedList(...));

链表是一种物理存储上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成，节点可以在运行时动态生成。

单向链表的节点包括两个结构：

• 存储数据元素的数据域；
• 存储下一个节点地址的指针域；

双向链表的节点包括三个结构：

• 存储数据元素的数据域；
• 存储下一个节点地址的指针域；
• 存储上一个节点地址的指针域；

二、相关源码

LinkedList继承自AbstractSequentialList抽象类，并且实现了List<E>, Deque<E>, Cloneable, java.io.Serializable接口。

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

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

• 属性

//链表的长度
transient int size = 0;
//指向第一个节点的指针。
transient Node<E> first;

//指向最后一个节点的指针。
transient Node<E> last;

• 构造函数

//构造一个空列表
public LinkedList() {
}

//构造一个包含指定元素的列表集合，按照集合返回它们的顺序迭代器。
//c: 要将其元素放入此列表的集合
//如果指定的集合为空,抛出空指针NullPointerException异常
public LinkedList(Collection<? extends E> c) {
    //调用无参构造
    this();
    addAll(c);
}

三、常用API

【a】linkFirst()、linkLast()、linkBefore()、unlinkFirst()、unlinkLast()、unlink()

//链接e作为第一个元素。
private void linkFirst(E e) {
    final Node<E> f = first;
    //构造插入的新Node节点对象
    //prev = null  item = e  next=f
    final Node<E> newNode = new Node<>(null, e, f);
    //将新节点作为指向第一个节点的指针
    first = newNode;
    if (f == null)
       //如果f为空则新节点就是最后一个节点
        last = newNode;
    else
    //如果f不为空，则f的上一个节点是newNode
        f.prev = newNode;
    //链表长度加1
    size++;
    modCount++;
}

//链接e作为最后一个元素。
void linkLast(E e) {
    final Node<E> l = last;
    // 构造新的最后一个节点,所以next为null,prev就是指向原先的最后一个节点
    // 前面一个节点prev = l 、 数据域item = e、 后面一个节点next = null
    final Node<E> newNode = new Node<>(l, e, null);
    //设置新节点作为最后一个节点
    last = newNode;
    
    //判断之前链表是不是为空集合
    if (l == null)
        //如果原先最后一个节点为空，则新节点也是第一个节点（头尾都是新节点）
        first = newNode;
    else
        //如果原先最后一个节点不为空，则设置下一个节点是newNode
        l.next = newNode;
    //链表长度加1    
    size++;
    modCount++;
}

//在非空节点succ之前插入元素e
void linkBefore(E e, Node<E> succ) {
    //首先拿到原先succ的前面一个节点
    final Node<E> pred = succ.prev;
    
    //重新构造 (pred <-- e --> succ) 的新节点
    final Node<E> newNode = new Node<>(pred, e, succ);
    
    //修改原succ节点的前面一个节点为新插入的节点newNode
    succ.prev = newNode;
    
    if (pred == null)
        //如果原先succ的前面一个元素为空，也就是新节点newNode充当首节点
        first = newNode;
    else
        //重新指向pred的下一个节点为新节点newNode
        pred.next = newNode;
    //链表长度加1
    size++;
    modCount++;
}

//取消非空的第一个节点f的链接。
private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    final E element = f.item;
    //拿出原先x指向的下一个节点
    final Node<E> next = f.next;
    //将item值和下一个节点置空
    f.item = null;
    f.next = null; // help GC
    //将原先x指向的下一个节点变为第一个节点
    first = next;
    if (next == null)
        //原先x指向的下一个节点为空，则将最后一个节点设置为空
        last = null;
    else
        //原先x指向的下一个节点不为空,则将next上一节点设置为空
        next.prev = null;
    //链表长度减1    
    size--;
    modCount++;
    //返回原先x的值
    return element;
}

//取消非空最后一个节点l的链接
private E unlinkLast(Node<E> l) {
    // assert l == last && l != null;
    //拿到原先l节点的值
    final E element = l.item;
    //拿到原先l节点指向的上一个节点
    final Node<E> prev = l.prev;
    //将item和上一节点置空
    l.item = null;
    l.prev = null; // help GC
    //将原先l节点指向的上一个节点设置为当前最后一个节点
    last = prev;
    if (prev == null)
        //如果原先l节点指向的上一个节点为空，则将第一个节点设置为空
        first = null;
    else
        //如果原先l节点指向的上一个节点不为空，则将prev下一节点设置为空
        prev.next = null;
   //链表长度减1      
    size--;
    modCount++;
    return element;
}

//取消非空节点x的链接。
E unlink(Node<E> x) {
    //x是要删除的节点
    final E element = x.item;
    //拿出原先x指向的下一个节点
    final Node<E> next = x.next;
    //拿出原先x指向的上一个节点
    final Node<E> prev = x.prev;
    
    //如果删除节点前面一个节点为空
    if (prev == null) {
        //头部指向x删除节点的后面一个节点
        first = next;
    } else {
        //如果删除节点前面一个节点不为空，则修改原先上一个节点的下一节点指向
        prev.next = next;
        //设置x前面节点为空
        x.prev = null;
    }

    // 假设原先关系如下所示：  x前面一个节点prev,x后面一个节点next
    //(prev) <-- (x) --> (next)
    //如果删除节点后面一个节点为空，则prev将作为最后一个节点
    if (next == null) {
        last = prev;
    } else {
        //如果后面一个节点不为空，则修改原先下一个节点的上一节点指向
        // (prev) <-- (next)
        next.prev = prev;
        // (x) --> (null) : 删除节点x的后继节点为null
        //设置x后面节点为空
        x.next = null;
    }
    //修改x的值为空
    x.item = null;
    //链表长度减1 
    size--;
    modCount++;
    return element;
}

【b】getFirst()、getLast()

//返回列表中的第一个元素。
public E getFirst() {
    //直接获取LinkedList内部指向第一个节点的指针。
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    //返回node对应的数据域
    return f.item;
}

//返回列表中的最后一个元素。
public E getLast() {
    //直接获取LinkedList内部指向最后一个节点的指针。
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    //返回node对应的数据域   
    return l.item;
}

【c】removeFirst()、removeLast()

//从列表中删除并返回第一个元素。
public E removeFirst() {
    //直接获取LinkedList内部指向第一个节点的指针。
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    //直接调用取消非空的第一个节点链接的方法
    return unlinkFirst(f);
}

//从列表中移除并返回最后一个元素
public E removeLast() {
    //直接获取LinkedList内部指向最后一个节点的指针。
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    //直接调用取消非空的最后一个节点链接的方法    
    return unlinkLast(l);
}

【d】addFirst()、addLast()

//将指定的元素插入此列表的开头
public void addFirst(E e) {
    linkFirst(e);
}

//将指定的元素追加到此列表的末尾。
public void addLast(E e) {
    linkLast(e);
}

【e】contains()、size()

//如果此列表包含指定的元素，则返回true，否则返回false
public boolean contains(Object o) {
    return indexOf(o) != -1;
}

//返回列表中元素的数目。
public int size() {
    return size;
}

【f】add()、remove()、addAll()、node()

//将指定的元素追加到此列表的末尾。
public boolean add(E e) {
    linkLast(e);
    return true;
}

/**
* 从列表中删除指定元素的第一个匹配项，如果它存在。如果此列表不包含该元素，则它包含不变
 * @param o 元素将从此列表中删除(如果存在)
 * @return {@code true} 如果此列表包含指定的元素
 */
public boolean remove(Object o) {
    if (o == null) {
        //需要删除的元素为空时，循环遍历链表挨个比较是否为null,是的话就调用unlink取消非空节点的链接。
        //从第一个节点开始遍历，知道节点node下一个节点为null，遍历结束
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        //需要删除的元素不为空时，循环遍历使用equals方法判断item是否相等,相等的话就调用unlink取消非空节点的链接。
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

//将指定集合中的所有元素追加到此列表，按它们被指定的方式返回的顺序排列集合的迭代器
public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}

//将指定集合中的所有元素插入其中列表，从指定位置开始
public boolean addAll(int index, Collection<? extends E> c) {
    //检查下标是否越界
    checkPositionIndex(index);
    //将集合先转换为对象数组
    Object[] a = c.toArray();
    //本次需要新增加的元素个数
    int numNew = a.length;
    //如果需要增加的元素长度为0，直接返回新增失败false
    if (numNew == 0)
        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)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }

    if (succ == null) {
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }

    size += numNew;
    modCount++;
    return true;
}

//返回指定元素索引处的(非空)节点。
Node<E> node(int index) {
    // assert isElementIndex(index);
    //size >> 1 相当于 (size / 2)
    //如果索引在左半部分的话，从第一个节点开始循环遍历(从前往后找)
    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;
    }
}

private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

//检查参数是否在索引范围内，即检查是否越界
private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}

【g】clear()

//从列表中删除所有元素。调用返回后，列表将为空。
public void clear() {
    // Clearing all of the links between nodes is "unnecessary", but:
    // - helps a generational GC if the discarded nodes inhabit
    //   more than one generation
    // - is sure to free memory even if there is a reachable Iterator
    
    //循环遍历链表，将所有节点的值、前面一个节点、后面一个节点全部置空
    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;
    //链表长度更新为0
    size = 0;
    modCount++;
}

【h】get()、set()、add()、remove()

//返回列表中指定位置的元素。
public E get(int index) {
    //检查下标是否越界，越界会抛出IndexOutOfBoundsException异常
    checkElementIndex(index);
    //返回指定索引处的(非空)节点。
    return node(index).item;
}

//返回指定元素索引处的(非空)节点。
Node<E> node(int index) {
    // assert isElementIndex(index);
    //size >> 1 相当于 (size / 2)
    //如果索引在左半部分的话，从第一个节点开始循环遍历
    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;
    }
}

//将列表中指定位置的元素替换为指定元素。
public E set(int index, E element) {
    //检查下标是否越界，越界会抛出IndexOutOfBoundsException异常
    checkElementIndex(index);
    //获取指定下标处的节点元素
    Node<E> x = node(index);
    //原先节点处的item值
    E oldVal = x.item;
    //直接替换item为新值element
    x.item = element;
    //返回替换前的值
    return oldVal;
}

//将指定元素插入到列表中的指定位置。
public void add(int index, E element) {
    //检查下标是否越界，越界会抛出IndexOutOfBoundsException异常
    checkPositionIndex(index);

    //判断是否在尾部直接插入
    if (index == size)
        //如果是在最后一个位置插入元素,则实际上就是链接element作为最后一个元素
        linkLast(element);
    else
        //在非空节点之前插入元素element。
        linkBefore(element, node(index));
}

//删除列表中指定位置的元素。后续元素的索引中减去1
public E remove(int index) {
     //检查下标是否越界，越界会抛出IndexOutOfBoundsException异常
    checkElementIndex(index);
    //获取对应索引的值
    //然后取消非空节点node(index)的链接
    return unlink(node(index));
}

【i】indexOf()、lastIndexOf()

//返回指定元素第一次出现的索引,在该列表中，如果该列表不包含该元素，则为-1。
public int indexOf(Object o) {
    int index = 0;
    //当o为空的时候，就是循环链表挨个判断是否为null,返回第一个为null的元素的下标
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        //当o不为空的时候，就是循环链表拿出item使用equals()方法挨个判断是否相等,返回第一个相等的元素对应的下标
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    return -1;
}

//返回指定元素最后一次出现的索引。在该列表中，如果该列表不包含该元素，则为-1。
public int lastIndexOf(Object o) {
    int index = size;
    //同上indexOf()是正序循环遍历链表，lastIndexOf()则从last最后一个节点开始遍历
    //比较方法都跟indexOf()一样
    if (o == null) {
        for (Node<E> x = last; x != null; x = x.prev) {
            index--;
            if (x.item == null)
                return index;
        }
    } else {
        for (Node<E> x = last; x != null; x = x.prev) {
            index--;
            if (o.equals(x.item))
                return index;
        }
    }
    return -1;
}

【j】队列的操作相关API

//检索但不删除此列表的头(第一个元素)
public E peek() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}

//检索但不删除此列表的头(第一个元素)
public E element() {
    return getFirst();
}

//检索并删除此列表的头(第一个元素)。
public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

//检索并删除此列表的头(第一个元素)。
public E remove() {
    return removeFirst();
}

//将指定的元素添加为此列表的末尾(最后一个元素)。
public boolean offer(E e) {
    return add(e);
}

【k】双端队列的操作API

//将指定的元素插入此列表的前面。
public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}

//在列表末尾插入指定的元素。
public boolean offerLast(E e) {
    addLast(e);
    return true;
}

//检索但不删除此列表的第一个元素，如果该列表为空，则返回null。
public E peekFirst() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
 }

//检索但不删除此列表的最后一个元素，如果该列表为空，则返回null。
public E peekLast() {
    final Node<E> l = last;
    return (l == null) ? null : l.item;
}

//检索并删除列表中的第一个元素，如果该列表为空，则返回{@code null}。
public E pollFirst() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

//检索并删除列表中的最后一个元素，如果该列表为空，则返回{@code null}。
public E pollLast() {
    final Node<E> l = last;
    return (l == null) ? null : unlinkLast(l);
}

//将元素推入此列表所表示的堆栈。将元素插入到列表的前面。
public void push(E e) {
    addFirst(e);
}

//从该列表表示的堆栈中弹出一个元素。删除并返回列表的第一个元素。
public E pop() {
    return removeFirst();
}

【l】superClone()、clone()

@SuppressWarnings("unchecked")
private LinkedList<E> superClone() {
    try {
        return (LinkedList<E>) super.clone();
    } catch (CloneNotSupportedException e) {
        throw new InternalError(e);
    }
}

//返回此LinkedList的浅拷贝。
public Object clone() {
    LinkedList<E> clone = superClone();

    // Put clone into "virgin" state
    clone.first = clone.last = null;
    clone.size = 0;
    clone.modCount = 0;

    //初始化克隆
    for (Node<E> x = first; x != null; x = x.next)
        clone.add(x.item);

    return clone;
}

【m】toArray()

//返回一个包含列表中所有元素的数组
public Object[] toArray() {
    Object[] result = new Object[size];
    int i = 0;
    //循环链表，依次将item的值赋值给数组对应下标的值
    for (Node<E> x = first; x != null; x = x.next)
        result[i++] = x.item;
    return result;
}

//返回一个包含列表中所有元素的数组
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
    if (a.length < size)
        a = (T[])java.lang.reflect.Array.newInstance(
                            a.getClass().getComponentType(), size);
    int i = 0;
    Object[] result = a;
    for (Node<E> x = first; x != null; x = x.next)
        result[i++] = x.item;

    if (a.length > size)
        a[size] = null;

    return a;
}

【n】writeObject()、readObject()

//将LinkedList实例的状态保存到一个流中.(也就是说，序列化它)。
private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    // Write out any hidden serialization magic
    s.defaultWriteObject();

    // Write out size
    s.writeInt(size);

    // Write out all elements in the proper order.
    //按适当的顺序写出所有的元素
    for (Node<E> x = first; x != null; x = x.next)
        s.writeObject(x.item);
}

//从流中重构这个{@code LinkedList}实例(即反序列化它)。
@SuppressWarnings("unchecked")
private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    // Read in any hidden serialization magic
    s.defaultReadObject();

    // Read in size
    int size = s.readInt();

    // Read in all elements in the proper order.
    //按适当的顺序读取所有元素。
    for (int i = 0; i < size; i++)
        linkLast((E)s.readObject());
}