LinkedList源码分析

LinkedList是一个实现了List接口和Deque接口的双端链表。 LinkedList底层的链表结构使它支持高效的插入和删除操作，另外它实现了Deque接口，使得LinkedList类也具有队列的特性; LinkedList不是线程安全的，如果想使LinkedList变成线程安全的，可以调用静态类Collections类中的synchronizedList方法：

List list=Collections.synchronizedList(new LinkedList(...));

​ LinkedList中每一个节点是一个Node类型的对象，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;
    }
}

​ 这个类就代表双端链表的节点Node。这个类有三个属性，分别是本节点的值element，前驱节点prev，后继结点next。

属性

// 记录LinkedList的大小
transient int size = 0;

// 指向链表的头节点
transient Node<E> first;

// 指向链表的尾节点
transient Node<E> last;

构造器

// 空参构造器
public LinkedList() {
}
// 根据指定的集合构建一个链表，链表中元素按照集合迭代器的返回顺序存放
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

​ 第二个构造器是通过调用addAll方法完成对指定集合的添加。该方法的作用是将参数集合从指定位置开始插入到链表中。

public boolean addAll(int index, Collection<? extends E> c) {
    // 首先进行合法性检验，保证元素插入到链表的索引位置在[0,size]范围内
    checkPositionIndex(index);
	// 将集合转换为对象数组
    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;
	// 创建两个指针，succ指向待添加节点的位置的后继节点
    // pred指向待添加节点的前一个节点
    Node<E> pred, succ;
    
    // 此处是对元素插入位置的一个分支判断
    // 1、如果插入的位置是链表的尾部，则pred指向last，succ指向null
    if (index == size) {
        succ = null;
        pred = last;
    } 
    // 2、如果插入的位置位于链表的中间，则succ指向待添加节点后继节点，该后继节点就是原来位于index位置的那个节点，可以通过node(index)方法获得，然后pred基于succ获得待添加节点的前驱结点。
    else {
        succ = node(index);
        pred = succ.prev;
    }
	
    // 遍历数组a，将其中的所有元素插入到链表中，采用尾插法
    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;
    }
	// 如果插入元素的位置是从链表尾部开始的，那么循环遍历完以后，pred指向的就是链表的最后一个元素，直接重置last节点即可
    if (succ == null) {
        last = pred;
    } 
    // 否则，将新插入的链表部分与先前index位置即其后部分的链表连接起来
    // 此时pred指向的就是新插入部分的最后一个节点，而succ指向的是原来位于index位置的那个节点
    else {
        pred.next = succ;
        succ.prev = pred;
    }
	// 修改链表的大小
    size += numNew;
    //modCount（修改的次数）自增1
    modCount++;
    return true;
}

分析一下node方法：

Node<E> node(int index) {
    // assert isElementIndex(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;
    }
}

​ 该方法的作用是返回指定元素索引处的（非空）节点，所以它的参数是一个索引。此处寻找指定索引位置的节点，进行了一些优化。不再是拿着指定的索引值就从头去遍历链表，而是先判断这个指定的索引值位于链表中的前半部分还是后半部分，如果index位于前半部分则从头开始遍历查找（使用的是next指针）；如果index位于链表的后半部分，则从链表尾部节点开始从后向前遍历查找链表（使用的是prev指针）。

添加元素的方法

add(E e)

将元素添加到链表尾部

public boolean add(E e) {
    linkLast(e);
    return true;
}
// 将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++;
}

offer(E e)

public boolean offer(E e) {
    return add(e);
}

当LinkedList作为队列的时候，可以作为入队操作来使用。底层调用的是add方法，将元素添加到链表的尾部。

add(int index, E element)

在指定位置插入元素

public void add(int index, E element) {
    // 插入位置的合法性检验：[0,size]
    checkPositionIndex(index);
	// 添加到链表尾部
    if (index == size)
        linkLast(element);
    // 将元素插入到链表的中间位置
    else
        linkBefore(element, node(index));
}
// succ指向当前待插入节点的后继节点，它是通过node(index)方法获得的
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    // 获得待插入节点的前驱节点
    final Node<E> pred = succ.prev;
    // 创建新节点
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

addFirst(E e)

将元素添加到链表头部

public void addFirst(E e) {
    linkFirst(e);
}
private void linkFirst(E e) {
    final Node<E> f = first;
    // 新建节点，以头节点为后继节点
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    //如果链表为空，last节点也指向该节点
    if (f == null)
        last = newNode;
    //否则，将原来的头节点的前驱指针指向新节点，也就是指向前一个元素
    else
        f.prev = newNode;
    size++;
    modCount++;
}

push(E e)

public void push(E e) {
    addFirst(e);
}

当链表作为栈使用时，该方法作为入栈操作来使用，实质就是将元素添加到链表头部。

根据位置获取数据的方法

get(int index)

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

​ 根据指定索引返回数据。实质上调用的是node(index)方法，注意，由于node方法内部没有对索引位置值进行合法性检验，所以在调用node方法之前一定要对index进行合法性检验。

获取链表头节点的方法

public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
}
public E element() {
        return getFirst();
}
public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
}

public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
}

​ element方法底层调用的就是getFirst方法，所以它们可以看作是一样的。这两个方法获取头节点时，如果链表是一个空链表，则会抛出异常；

​ peek和peekFirst的内部逻辑是一样的，所以这两个方法作用也一样，它们在获取头节点时，如果遇到了空链表，则不会抛出异常，而是返回一个null。

获取链表尾部节点的方法

 public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }
 public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }

getLast() 方法在链表为空时，会抛出NoSuchElementException，而peekLast() 则不会，只是会返回 null。

根据对象获取索引的方法

indexOf(Object o)

public int indexOf(Object o) {
    int index = 0;
    // 如果寻找的是null值，从链表头开始遍历寻找链表中是否有null，若有则返回其索引位置，没有返回-1
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } 
    // 从头遍历寻找与对象o相等的元素
    else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    return -1;
}

​ 可以看到在链表中寻找与指定对象相等的元素时，如果指定元素是null，则直接用“==”判断是否相等；如果不是null，则使用equals方法判等，所以定义一个类的时候，一定要重写它的equals方法。

​ 其中，LinkedList中的contains方法调用的也是indexOf方法，如果返回-1说明不包含指定的元素，否则就是包含。

public boolean contains(Object o) {
    return indexOf(o) != -1;
}

lastIndexOf(Object o)

​ 从尾部开始遍历寻找与指定对象相等的元素的位置。

public int lastIndexOf(Object o) {
    int index = size;
    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;
}

删除方法

删除头节点

// 链表作为栈使用时，可以作为出栈操作
public E pop() {
        return removeFirst();
}

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

public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
}
//链表作为队列时，可以作为出队操作
public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

​ pop、remove、removeFirst方法在链表为空时执行将抛出NoSuchElementException异常，而poll方法则是返回null。

删除尾节点

public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }
public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
}

​ removeLast()在链表为空时将抛出NoSuchElementException，而pollLast()方法返回null。

删除指定元素

​ 从此列表中删除第一次出现的指定元素，如果链表中有多个元素与指定元素相等，那么就只删除第一个出现的那个元素。如果删除了匹配对象，返回true，否则false。

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

​ remove执行的删除操作最终都是由unlink方法完成的，下面分析一下unlink方法的源码：

E unlink(Node<E> x) {
    // assert x != null;
    final E element = x.item;
    // 得到x的后继节点
    final Node<E> next = x.next;
    // 得到x的前驱节点
    final Node<E> prev = x.prev;
	
    // 如果删除的节点是头节点,令头节点指向该节点的后继节点
    if (prev == null) {
        first = next;
    } 
    // 将前驱节点的后继指针指向x的后继节点，并将x的前驱指针指向null
    else {
        prev.next = next;
        x.prev = null;
    }
	//如果删除的节点是尾节点,令尾节点指向该节点的前驱节点
    if (next == null) {
        last = prev;
    } 
    // 将x节点的后继节点的前驱指针指向x节点的前驱节点，并将x的后继指针指向null
    else {
        next.prev = prev;
        x.next = null;
    }
	
    x.item = null;
    size--;
    modCount++;
    return element;
}

该方法的整个执行步骤是：

​ （1）获取指定对象的前驱节点和后继节点；

​ （2）判断当前指定对象是否是头节点：

​ 1）如果是头节点，则将头节点指针指向当前节点的后继节点；

​ 2）如果不是头节点，则将该节点的前驱节点的后继指针指向该节点的后继节点，并将当前节点的前驱指针设置为null；

​ （3）判断当前对象是否是尾部节点：

​ 1）如果是尾部节点，则将尾指针指向该节点的前驱节点；

​ 2）如果不是尾部节点，则将该节点的后继节点的前驱指针指向该节点的前驱节点，并将当前节点的后继指针设置为null；

​ （3）将当前节点值设置为null，以便于回收。

​ （4）链表大小减1，链表结构修改次数加1，并返回被删除的节点对象。

​ remove(int index)方法底层调用的是node(index)和ublink方法，先利用node获取指定索引位置的节点对象，然后用unlink方法将这个对象进行删除，只不过先进行了索引位置的合法性检验。

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

总结

1、LinkedList可以存储null值

2、LinkedList底层是一个双向链表，线程不安全

3、LinkedList既可以作为队列使用，出队和入队的组合操作是poll和offer；也可以作为栈使用，出栈和入栈的组合操作是pop和push。

4、往链表中插入元素的方法是尾插法

5、链表的顺序访问效率高，随机访问的效率低。在依据index值进行随机访问时，进行了优化，先对index在链表中的大致位置进行了判断，如果index位于链表的左半部分就从头向后遍历；如果index位于链表的右半部分，就从后向前遍历。

6、链表比较浪费空间的原因是对于每一个节点对象，都包含了一个指向前驱和一个指向后继的指针。

7、LinkedList采用链表存储，所以对于add(E e)方法的插入，删除元素时间复杂度不受元素位置的影响，近似 O(1)，如果是要在指定位置i插入和删除元素的话时间复杂度近似为O(n)因为需要先移动到指定位置再插入。

参考文献：https://snailclimb.gitee.io/javaguide/#/docs/java/collection/LinkedList源码分析