Java集合源码解析 - LinkedList

概述

LinkedList是一个以双向链表实现的List，同时可作为队列(FIFO)与栈(LIFO)使用(非线程安全)

UML类图

LinkedList实现了List接口，提供了增删改查的基础操作；

LinkedList实现了Serializable接口，可以被序列化；

LinkedList实现了Cloneable接口，可以被克隆；

LinkedList实现了Deque接口，可作为双端队列；

源码解析

属性

//节点个数
transient int size = 0;
//链表首节点
transient Node<E> first;
//链表尾节点
transient Node<E> last;

//双向链表节点
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;
    }
}

构造器

//无界队列

//默认构造器
public LinkedList() {
}

//带参(集合)构造器
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

方法

作为双端队列，那么可以分别从队首与队尾插入节点、删除节点

作为List，支持从中间插入节点、删除节点

作为队列(FIFO)，只需要操作队尾节点

作为栈(LIFO)，只需要操作队首节点

linkFirst(E e)

功能

从队首插入元素，平均时间复杂度为O(1)

源码

private void linkFirst(E e) {
    //将队首指针赋值给f
    final Node<E> f = first;
    //创建新节点，其next节点指向队首节点
    final Node<E> newNode = new Node<>(null, e, f);
    //队首指针指向节点
    first = newNode;
    if (f == null)
  	//第一次插入元素，队首与队尾指向同一节点
        last = newNode;
    else
        //否则原队首节点的前置节点指向新节点
        f.prev = newNode;
    //元素个数+1
    size++;
    // fail-fast机制
    modCount++;
}

linkLast(int index, E e)

功能

添加元素到数组指定位置，平均时间复杂度O(1);

源码

/**
 * 从队尾添加元素
 */
void linkLast(E e) {
    //将队尾指针赋值给l
    final Node<E> l = last;
    //创建新节点，其prev节点指向末尾节点
    final Node<E> newNode = new Node<>(l, e, null);
    //移动队尾指针指向新节点
    last = newNode;
    if (l == null)
  		//第一次插入元素时，队首与队尾指向同一节点
        first = newNode;
    else
        //原队尾节点的后置节点指向新节点
        l.next = newNode;
    //元素个数+1
    size++;
    // 修改次数加1，说明这是一个支持fail-fast的集合
    modCount++;
}

linkBefore(E e, Node succ)

功能

从指定位置处插入节点，平均时间复杂度O(n);

源码

public void add(int index, E element) {
    //判断数组越界
    checkPositionIndex(index);
    if (index == size)
        //从队尾插入
        linkLast(element);
    else
        //查找指定下标的节点
        //从中间插入
        linkBefore(element, node(index));
}

//查找指定下标的节点
Node<E> node(int 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;
    }
}

/**
 * @param e 要插入的节点数据
 * @param succ index位置的节点
 */
void linkBefore(E e, Node<E> succ) {
    // 参数节点的上一节点赋值给pred
    final Node<E> pred = succ.prev;
    //创建新节点，prep节点指向参数节点的上一节点，next节点指向参数节点
    final Node<E> newNode = new Node<>(pred, e, succ);
    //参数节点的上一节点指向新节点
    succ.prev = newNode;
    if (pred == null)
        //第一次添加，first节点指向新节点
        first = newNode;
    else
        //参数节点的上一节点的next节点指向新节点
        pred.next = newNode;
    //节点个数+1
    size++;
    //fail-fast机制
    modCount++;
}

unlinkFirst (Node f)

功能

功能：删除队首元素，并返回队首元素，平均时间复杂度为O(1)

源码

//removeFirst没有元素抛异常
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

// poll，没有元素返回null
public E pollFirst() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

private E unlinkFirst(Node<E> f) {
    // 获取队首节点
    final E element = f.item;
    // 获取队首节点的next节点，若next为null，则代表LinkedList只有一个元素
    final Node<E> next = f.next;
    //清除元素
    f.item = null;
    f.next = null;
    //将下一个节点置为队首节点
    first = next;
    if (next == null)
        last = null;
    else
        //对首节点的prev节点为null
        next.prev = null;
    size--;
    modCount++;
    return element;
}

unlinkLast(Node l)

功能

功能：删除队尾节点，并返回队尾元素，平均时间复杂度为O(1)

源码

//removeLast,没有节点抛异常
public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}

// poll，没有节点返回null
public E pollLast() {
    final Node<E> l = last;
    return (l == null) ? null : unlinkLast(l);
}

private E unlinkLast(Node<E> l) {
    // 获取队尾节点
    final E element = l.item;
    // 获取队尾节点的prev节点，若prev为null，则代表LinkedList只有一个元素
    final Node<E> prev = l.prev;
    //清除元素
    l.item = null;
    l.prev = null; // help GC
    //将last指向对尾元素的prev节点
    last= prev ;
    if (prev== null)
        first= null;
    else
        //队首元素的prev节点为null,队尾元素的next节点为null
        prev.next= null;
    size--;
    modCount++;
    return element;
}

E unlink(Node x)

功能

功能：删除指定节点，并返回该节点元素，平均时间复杂度O(n)

源码

//删除指定下标的节点
public E remove(int index) {
    //检测数组是否越界
    checkElementIndex(index);
    //node(index),查找节点
    return unlink(node(index));
}

//删除指定元素的节点
public boolean remove(Object o) {
    //先获取与该元素相等的节点，调用unlink()删除
    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;
}

//删除指定节点
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指向下一个节点
        first = next;
    } else {
        //否则prev节点的nexe指向next,清除prev
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        //为队尾节点时，last指针指向上一个节点
        last = prev;
    } else {
        //否则next节点的prev指向prev，清除next
        next.prev = prev;
        x.next = null;
    }

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

总结

LinkedList是一个以双向链表实现的List，同时还是一个双端队列，具有双端队列、栈的特性
LinkedList在队首队尾插入元素速度极快，平均时间复杂度O(1)
LinkedList在中间插入元素速度较慢，平均时间复杂度O(n)，主要花费在查找指定节点
LinkedList不支持随机访问，需遍历查找
线程安全可使用Collections.synchronizedList(List list)