基于java1.8 LinkedList 源码分析

1、结构

• LinkedList 继承 AbstractSequentialList 抽象类，该类是只支持按次序访问
• LinkedList 实现了 List 接口
• LinkedList 实现了 Deque 接口，即能被当作双端队列
• 实现了 Cloneable 接口，覆盖了 clone 方法，即可以被克隆
• 实现了 Serializable 接口，支持序列化

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

2、内部变量

// 链表的长度
transient int size = 0;

// 头节点
transient Node first;

// 尾节点
transient Node last;

// 这是一个双向链表改有的基本结构，包括指向前面的节点、数据、指向后面的节点
private static class Node {
    E item;
    Node next;   //指向下一个节点
    Node prev;   //指向上一个节点

    Node(Node prev, E element, Node next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

3、构造函数

/**
 * Constructs an empty list.
 */
public LinkedList() {
}

/**
 * Constructs a list containing the elements of the specified
 * collection, in the order they are returned by the collection's
 * iterator.
 *
 * @param  c the collection whose elements are to be placed into this list
 * @throws NullPointerException if the specified collection is null
 */
public LinkedList(Collection c) {
    this();
    addAll(c);
}

4、主要方法{get()、set()、add()、remove()、clear()、contains()}

4.1 get()

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

4.2 set()

public E set(int index, E element) {
    checkElementIndex(index);
    Node x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

4.3 add()

// 在集合尾部添加元素
public boolean add(E e) {
    linkLast(e);
    return true;
}

// 在集合的指定位置添加值
public void add(int index, E element) {
    checkPositionIndex(index);
    
    // 如果插入位置正好是集合最后一位的后一位
    if (index == size)
        // 则在链表最后添加
        linkLast(element);
    else
        // 否则先根据位置确定对应的元素
        // 然后把指定值插入到该元素的前面
        linkBefore(element, node(index));
}

/**
 * Returns the (non-null) Node at the specified element index.
 */
Node node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

// 在指定位置插入一个集合
public boolean addAll(int index, Collection c) {
    checkPositionIndex(index);
    
    // 将传入的集合转为 Object 数组
    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;
    
    // 定义两个节点，pred 是插入位置的前一个节点，succ 是插入位置的后一个节点
    Node pred, succ;
    // 直接将集合插入到最后
    if (index == size) {
        // succ 没什么用，直接置空
        succ = null;
        // pred 用来保存每插入一个元素的位置
        pred = last;
    // 如果集合不是插入到尾部
    } else {
        succ = node(index);
        pred = succ.prev;
    }

     // 遍历集合数组
    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
        // 创建新节点，向前指向 pred
        Node newNode = new Node<>(pred, e, null);
        // 如果 pred 为空，表明新建的节点是头节点
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        // pred 保存最后一个新建节点的位置
        pred = newNode;
    }
    
    // 如果 succ 是 null，说明集合是直接插入到尾部的
    if (succ == null) {
        // 此时插入的最后一个元素便是尾节点
        last = pred;
    // 否则，将插入的最后一个元素和插入位置的后一个节点相连接
    } else {
        pred.next = succ;
        succ.prev = pred;
    }

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

// 将集合直接插入到尾部
public boolean addAll(Collection c) {
    return addAll(size, c);
}

// 在集合头部插入元素
public void addFirst(E e) {
    linkFirst(e);
}

// 在集合尾部插入元素
public void addLast(E e) {
    linkLast(e);
}

// 把数据插入到链表头部
private void linkFirst(E e) {
    // 获取当前链表的头节点
    final Node f = first;
    // 创建一个节点，向前指向 null，向后指向当前链表的头节点 f
    final Node newNode = new Node<>(null, e, f);
    // f 指向新的节点
    first = newNode;
    // 如果 f 为空(添加之前什么也没有)，则链表的尾节点也指向新建节点
    // 此时链表的头节点和尾节点都指向这个新创建的节点
    if (f == null)
        last = newNode;
    // 如果 f 不为空(添加之前头节点已经有了)，原来的头节点向前指向新的节点
    else
        f.prev = newNode;
    size++;
    modCount++;
}

// 把数据插入到链表尾部
void linkLast(E e) {
    // 获取当前链表的尾节点
    final Node l = last;
    // 创建一个节点，向前指向该链表的尾节点，向后指向 null
    final Node newNode = new Node<>(l, e, null);
    // 将 l(之前的尾节点) 指向新的节点
    last = newNode;
    // 如果 l 为空，则链表的头节点也指向该新节点，此时链表的头和尾节点都指向该节点
    if (l == null)
        first = newNode;
    // 如果 l 不为空(链表不为空)，则原来的尾节点向后指向新创建的节点
    else
        l.next = newNode;
    size++;
    modCount++;
}

// 在指定节点前面插入值，这里假设指定节点不为空
void linkBefore(E e, Node succ) {
    // 获取指定节点的前一个节点
    final Node pred = succ.prev;
    // 创建一共新节点，向前指向 succ 节点的前一个节点，向后指向 succ 节点，数值是 e
    final Node newNode = new Node<>(pred, e, succ);
    // succ 向前指向新建的节点
    succ.prev = newNode;
    // 如果 succ 前面的节点为空，则新建的节点就是第一个节点
    if (pred == null)
        first = newNode;
    // 如果 succ 前面的节点不为空，则用 succ 节点向后指向新建的节点
    // 此时代表插入完成
    else
        pred.next = newNode;
    size++;
    modCount++;
}

4.4 remove()

// 删除集合中的第一个元素
public E remove() {
    return removeFirst();
}

// 删除集合中指定位置的节点
public E remove(int index) {
    checkElementIndex(index);
    // 先使用 node(int index) 方法找到指定位置的节点
    // 调用 unlink(Node x) 删除该节点
    return unlink(node(index));
}

// 删除集合中指定的元素(如果集合中有不止一个，则只删除前面一个)
public boolean remove(Object o) {
    // 如果指定元素为 null
    if (o == null) {
        // 遍历链表中的元素
        for (Node x = first; x != null; x = x.next) {
            // 只要遍历到 null，删除并返回 true
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    // 否则，直接根据节点中的元素进行判断
    } else {
        for (Node x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

// 删除第一个头节点，返回删除的元素
public E removeFirst() {
    final Node f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

// 删除最后一个节点，返回删除的元素
public E removeLast() {
    final Node l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}

// 删除指定元素(从前往后如果有相同的则只删除第一次出现的)，就是 remove(Object o) 方法
public boolean removeFirstOccurrence(Object o) {
    return remove(o);
}

// 删除指定元素(从后往前如果有相同的则只删除第一次出现的)，就是倒置的 remove(Object o) 方法
public boolean removeLastOccurrence(Object o) {
    if (o == null) {
        for (Node x = last; x != null; x = x.prev) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node x = last; x != null; x = x.prev) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

4.5 clear()

// 清空集合方法
public void clear() {
    // 这里将链表从头到末尾每个节点的元素，向前之前，向后指向前部置空
    for (Node x = first; x != null; ) {
        Node next = x.next;
        x.item = null;
        x.next = null;
        x.prev = null;
        x = next;
    }
    first = last = null;
    size = 0;
    modCount++;
}

4.6 contains()

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

public int indexOf(Object o) {
    int index = 0;
    if (o == null) {
        for (Node x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        for (Node x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    return -1;
}

4.7 遍历

// 迭代器
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
    iterator.next();
}

// for循环
for(int i=0; i

总结：

1. 底层使用链表，还是双向链表，增删快,查询慢
2. 可以添加null元素，可以添加相同的元素
3. 元素是有序的，输入顺序和输出顺序一致
4. 线程不安全的
5. for循环对 LinkedList 进行遍历，效率很低