Java容器学习--LinkedList源码分析

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

LinkedList 是一个继承于 AbstractSequentialList 的双向链表。它也可以被当作栈(Stack)、队列(Queue)或双端队列(Deque)进行操作。
LinkedList 实现了 List 接口，能对它进行列表操作。
LinkedList 实现了 Deque 接口，即能将 LinkedList 当作双端队列使用。
LinkedList 实现了 Cloneable 接口，即覆盖了函数Object.clone()，能被克隆。
LinkedList 实现了 java.io.Serializable 接口，这意味着 LinkedList 支持序列化，能通过序列化去传输。
LinkedList 是非同步的。

LinkedList 除了第一个结点没有头指针、最有一个结点没有尾指针，每一个结点都有一个唯一的头指针和尾指针。

属性

// 链表元素的个数
transient int size = 0;
// 链表头结点
transient Node<E> first;
// 链表尾结点
transient Node<E> last;

其中 Node 是一个静态内部类，代表了双向链表的每一个结点。
双向链表为空时，first与last都为null，size为0。

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() {
}
// 构造一个包含指定 collection 中的元素的列表
// 这些元素按其 collection 的迭代器返回的顺序排列
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

头插结点

private void linkFirst(E e) {                           
    final Node<E> f = first;                            
    final Node<E> newNode = new Node<>(null, e, f);     
    first = newNode;                                    
    if (f == null)                                      
        last = newNode;                                 
    else                                                
        f.prev = newNode;                               
    size++;                                             
    modCount++;                                         
}                                                       

第一次插入元素的时候

接下来插入元素

linkLast 是使用尾插法插入元素，与上边的插入情况类似就不做介绍了。
linkBefore(E e, Node<E> succ) 是在结点 succ 前插入结点。

删除结点

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; // 1       
        x.prev = null; // 2          
    }                           

    if (next == null) { // 删除尾结点        
        last = prev;            
    } else {                    
        next.prev = prev; // 3       
        x.next = null; // 4          
    }                           

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

在 Java 中一般删除结点包括两部分内容：
- 将与所删除的结点相关联的链删除，也就是删除结点间的引用关系
- 将所删除的结点的相关引用置为null，进行GC操作

unlinkFirst 是删除头结点
unlinkLast 是删除尾结点
以上两个操作和删除结点类似，不再介绍。

克隆

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

public Object clone() {                            
    LinkedList<E> clone = superClone();            

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

    // Initialize clone with our elements          
    for (Node<E> x = first; x != null; x = x.next) 
        clone.add(x.item);                         

    return clone;                                  
}                                                                                             

可以看到克隆操作先执行一个对 LinkedList 的克隆，然后对其进行尾插入法操作。

“随机访问”

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

因为是双向链表结构，所以是不支持随机访问的，即使存在随机访问的接口。而这些接口的实现也只是遵循顺序访问。
此处有一个小的优化：
当索引小于元素个数的一半时，从现象后遍历；否则从后往前遍历。（第一个元素的索引为0）

---

LinkedList 作为 Stack

public void push(E e) {
    addFirst(e);
}
public E pop() {         
    return removeFirst();
}
public E peek() {                      
    final Node<E> f = first;           
    return (f == null) ? null : f.item;
}
public boolean isEmpty() {
    return size() == 0;   
}                                                                                  

由于容器类库中并没有Stack接口，当我们仅需要栈操作的时候可以使用LinkedList自定义一个Stack。

package test;

import java.util.Collection;
import java.util.LinkedList;

public class Stack<E> {
    private LinkedList<E> stack = new LinkedList<>();

    public Stack() {
    }

    public Stack(Collection<? extends E> c) {
        for (E e : c) {
            stack.push(e);
        }
    }

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

    public E peek() {
        return stack.getFirst();
    }

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

    @Override
    public String toString() {
        return stack.toString();
    }
}

LinkedList 作为 Queue

Queue<String> queue = new LinkedList<>();

public interface Queue<E> extends Collection<E> {
    boolean add(E e);
    boolean offer(E e);
    E remove();
    E poll();
    E element();
    E peek();
}

LinkedList 作为 Deque

Deque<String> queue = new LinkedList<>();

public interface Deque<E> extends Queue<E> {
    void addFirst(E e);
    void addLast(E e);
    boolean offerFirst(E e);
    boolean offerLast(E e);
    E removeFirst();
    E removeLast();
    E pollFirst();
    E pollLast();
    E getFirst();
    E getLast();
    E peekFirst();
    E peekLast();
    boolean removeFirstOccurrence(Object o);
    boolean removeLastOccurrence(Object o);
    boolean add(E e);
    boolean offer(E e);
    E remove();
    E poll();
    E element();
    E peek();
    void push(E e);
    E pop();
    boolean remove(Object o);
    boolean contains(Object o);
    public int size();
    Iterator<E> iterator();
    Iterator<E> descendingIterator();
}