Java集合 | LinkedList源码分析(JDK 1.8)

一、基本图示

二、基本介绍

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

结构

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

特性

• 底层使用链表，还是双向链表
• 元素是有序的，输入顺序和输出顺序一致
• 是线程不安全的
• 可以添加元素 null，可以添加相同的元素

三、双向链表的基本结构

因为底层是双向链表，因此所有成员变量都和链表的属性有关

// 链表的长度
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;
    }
}

四、内部调用的方法

因为在调用增加、删除、修改方法的时候，都是直接调用这几个方法，因此就直接来看这几个方法。包括

• void linkFirst(E e)：把数值插入到链表头部
• void linkLast(E e)：把数值插入到链表尾部
• void linkBefore(E e, Node<E> succ)：在指定节点前面插入值(节点不为空)
• E unlinkFirst(Node<E> f)：删除不为空的头节点，返回删除的值
• E unlinkLast(Node<E> l)：删除不为空的尾节点，返回删除的值
• E unlink(Node<E> x)：删除不为空的指定节点
• Node<E> node(int index)：返回指定位置的节点

// 把数据插入到链表头部
private void linkFirst(E e) {
    // 获取当前链表的头节点
    final Node<E> f = first;
    // 创建一个节点，向前指向 null，向后指向当前链表的头节点 f
    final Node<E> 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<E> l = last;
    // 创建一个节点，向前指向该链表的尾节点，向后指向 null
    final Node<E> 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<E> succ) {
    // 获取指定节点的前一个节点
    final Node<E> pred = succ.prev;
    // 创建一共新节点，向前指向 succ 节点的前一个节点，向后指向 succ 节点，数值是 e
    final Node<E> newNode = new Node<>(pred, e, succ);
    // succ 向前指向新建的节点
    succ.prev = newNode;
    // 如果 succ 前面的节点为空，则新建的节点就是第一个节点
    if (pred == null)
        first = newNode;
    // 如果 succ 前面的节点不为空，则用 succ 节点向后指向新建的节点
    // 此时代表插入完成
    else
        pred.next = newNode;
    size++;
    modCount++;
}

// 删除不为空的头节点，返回删除节点的值
private E unlinkFirst(Node<E> f) {
    // 获取头节点的数据
    final E element = f.item;
    // 获取头节点的后面一个节点 next
    final Node<E> next = f.next;
    // 将头节点的数据置空
    f.item = null;
    // 将头节点向后指向 null
    f.next = null;
    // 此时后面一个节点变为头节点
    first = next;
    // 如果头节点向后指向 null，即原本链表中就这一个节点，移除后链表中就没有节点了
    if (next == null)
        last = null;
    // 如果头节点后面还有节点，那么删除的头节点就指向 null
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

// 删除不为空的尾节点，返回删除节点的值
private E unlinkLast(Node<E> l) {
    // 获取尾节点的数值
    final E element = l.item;
    // 获取尾节点的前面一个节点 prev
    final Node<E> prev = l.prev;
    // 将尾节点的置空
    l.item = null;
    // 将尾节点向前指向 null
    l.prev = null;
    // 此时前面一个节点变为链表的尾节点
    last = prev;
    // 如果尾节点的向前指向 null，即链表本来就只有这一个节点，移除后链表中就没有节点了
    if (prev == null)
        first = null;
    // 如果尾节点前面还有节点，则向后指向 null
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}

// 删除指定不为空的节点，返回节点对应的值
E unlink(Node<E> x) {
    // 获取要删除节点的值
    final E element = x.item;
    // 获取删除节点后面的节点 next，前面的节点 prev
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;
    
    // 如果要删除的节点前面没有节点，说明是第一个节点
    if (prev == null) {
        // 此时删除节点后面的那个节点变成头节点
        first = next;
    // 如果要删除的节点不是第一个
    } else {
        // 让要删除节点的前一个节点向后指向要删除节点的后一个节点，即直接跨过要删除的节点
        prev.next = next;
        // 同时向前指向 null
        x.prev = null;
    }

    // 如果要删除节点后面没有节点，说明是最后一个节点
    if (next == null) {
        // 此时删除节点前面那个节点变为尾节点
        last = prev;
    // 如果要删除的节点不是最后一个节点
    } else {
        // 让要删除节点的后一个节点向前指向要删除节点的前一个节点，还是跳过要删除的节点
        next.prev = prev;
        // 同时向后指向 null
        x.next = null;
    }
    
    // 将要删除的节点的值置空
    x.item = null;
    size--;
    modCount++;
    // 返回删除的节点
    return element;
}

// 获取指定位置的节点
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;
    }
}

需要注意 Node<E> node(int index) 方法，该方法会在后面的查找和删除等方法中用到，它的作用在于，是根据你传入的位置来判断是从链表的前面还是后开始查找，当传入位置小于长度的一半时，从前向后查找；否则，从后向前查找

五、添加方法

在指定位置进行插入的时候，会先调用 node(int index) 方法判断该位置是在集合长度的一半之后还是之后，如果小于长度一半则从前向后寻找位置，然后添加元素；否则，从后向前寻找位置，然后添加

// 在集合尾部添加元素
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));
}

// 在指定位置插入一个集合
public boolean addAll(int index, Collection<? extends E> c) {
    checkPositionIndex(index);
    
    // 将传入的集合转为 Object 数组
    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;
    
    // 定义两个节点，pred 是插入位置的前一个节点，succ 是插入位置的后一个节点
    Node<E> 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<E> 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<? extends E> c) {
    return addAll(size, c);
}

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

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

六、删除方法

主要包括三种

• 按照位置删除
• 按照指定元素删除(如果重复则只删除第一次出现的那个元素)
  • 从前往后寻找
  • 从后往前寻找
• 删除第一个或最后一个元素

如果从指定位置删除对应的元素，也会先判断位置然后再进行对应的操作，这一点和增加操作一样

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

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

// 删除集合中指定的元素(如果集合中有不止一个，则只删除前面一个)
public boolean remove(Object o) {
    // 如果指定元素为 null
    if (o == null) {
        // 遍历链表中的元素
        for (Node<E> x = first; x != null; x = x.next) {
            // 只要遍历到 null，删除并返回 true
            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;
}

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

// 删除最后一个节点，返回删除的元素
public E removeLast() {
    final Node<E> 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<E> x = last; x != null; x = x.prev) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node<E> x = last; x != null; x = x.prev) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

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

七、修改，获取的方法

// 在指定位置修改元素，返回被修改的元素的值
public E set(int index, E element) {
    checkElementIndex(index);
    // 获取 node(int index) 找到指定该位置的节点
    Node<E> x = node(index);
    // 获取该节点的元素，并替换
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

// 获取指定位置的元素
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

// 获取集合的第一个元素
public E getFirst() {
    // 获取头节点
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}

// 获取集合的最后一个元素
public E getLast() {
    // 获取尾节点
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}

八、其他方法

// 返回传入的元素在集合中的位置，如果没有则返回 -1
public int indexOf(Object o) {
    int index = 0;
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    return -1;
}

// 判断集合中是否存在传入的元素
public boolean contains(Object o) {
    return indexOf(o) != -1;
}

九、遍历方法

(1) 迭代器方式

Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
    iterator.next();
}

(2) 使用 for 循环

for(int i=0; i<list.size(); i++) {
    list.get(i);
}

(3) 使用 foreach

for(String i: list) {
    
}

其中迭代器和 foreach 遍历的方式速度基本是一样的，因为 foreach 本质上也是用迭代器进行遍历。一定不要使用 for 循环对 LinkedList 进行遍历，速度会慢到令人绝望

具体原因可以去看：http://www.cnblogs.com/xrq730/p/5189565.html

十、参考

https://blog.csdn.net/u011240877/article/details/52876543
https://www.cnblogs.com/xrq730/p/5005347.html