源码阅读：LinkedList

源码阅读：LinkedList

LinkedList介绍

• LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。
• LinkedList是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
• LinkedList实现 List 接口，能对它进行队列操作。
• LinkedList实现 Deque 接口，即能将LinkedList当作双端队列使用。
• LinkedList实现了Cloneable接口，即覆盖了函数clone()，能克隆。
• LinkedList是非同步的。

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

LinkedList数据结构

双向链表（Deque），每个元素包含两个指针，pre指向前一个节点，next指向后一个节点

头节点的pre为null，尾节点的next为null

element：存放元素、pre：用来指向前一个元素、next：指向后一个元素

因此对LinkedList我们可以从头开始正向遍历，或者是从尾开始逆向遍历，并且可以针对头部和尾部进行相应的操作

LinkedList源码分析

实现接口

1. List接口：列表，add、set、等一些对列表进行操作的方法

2. Deque接口：有队列的各种特性，

3. Cloneable接口：能够复制，使用那个copy方法。

4. Serializable接口：能够序列化。

类的属性

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    // 元素个数
    transient int size = 0;

    // 头节点
    transient Node<E> first;

    // 尾节点
    transient Node<E> last;

关键字有transient修饰，作用是使其在序列化时不会序列化

构造方法

public LinkedList() {
}

public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

有无参构造和有参构造两种方法，this()调用了无参构造方法，并把c中的元素添加到LinkedList中

Node类

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是实际存放元素的地方，实现了LinkedList的数据结构

核心方法

add(E)

public boolean add(E e) {
    linkLast(e);  // 将元素添加到末尾
    return true;
}

/**
 * Links e as last element.
 */
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)  // 判断是不是一开始链表中就什么都没有，如果没有，则newNode成为第一个节点
        first = newNode;
    else  // 正常的在最后一个节点后追加，原先的最后一个节点的next指向真正的最后一个节点
        l.next = newNode;
    size++;  // 添加一个节点
    modCount++;
}

remove(object o)

public boolean remove(Object o) {
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {  // 循环遍历链表，直到找到null值，然后使用unlink移除该值。
            if (x.item == null) {
                unlink(x);  // 使用unlink移除该值
                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.next = next;
        x.prev = null;  // 解除x节点的前指向
    }

    if (next == null) {  // 移除的节点是尾节点
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;  // 移除一个节点
    modCount++;
    return element;
}

实现栈和队列

根据官方技术文档说明，一个更加完整，一致的，后进先出的栈相关的操作，应该由 Deque接口提供。

原因是Stack类继承了Vector类（动态数组），导致stack可以使用add方法在任意位置插入数据，违背了stack数据结构的封装。

但实际上，Deque接口依然有相似的问题，双端队列使得我们可以对头尾两端进行操作。

	头元素	头元素	尾元素	尾元素
	抛出异常	返回特殊值	抛出异常	返回特殊值
插入方法	addFirst(e)	offerFirst(e)	addLast(e)	offerLast(e)
删除方法	removeFirst()	removeFirst()	removeLast()	removeLast()
检索方法	getFirst()	peekFirst()	getLast()	peekLast()

LinkedList特性总结

1. linkedList本质上是一个双向链表，通过一个Node内部类实现的这种链表结构。
2. 能存储null值
3. LinkedList在删除和增加等操作上性能好，而ArrayList在查询（随机访问）的性能上好
4. 当容量不足时可以自动扩容
5. 由于实现了Deque接口，LinkedList可以实现栈和队列的数据结构