【Java集合】LinkedList源码分析

1、属性

// LinkedList 的大小（它包含的元素数量）
transient int size = 0;

// 指向第一个节点的指针
transient Node<E> first;

// 指向最后一个节点的指针
transient Node<E> last;

2、内部节点

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

3、构造器

// 无参构造
public LinkedList() {
}

// 将传入的集合初始化进链表中
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

// 将指定的集合添加到链表的尾部
public boolean addAll(Collection<? extends E> c) {
    // 将指定集合中的所有元素插入此列表，从尾部开始。
    return addAll(size, c);
}
// 将指定集合中的所有元素插入此列表，从指定位置开始。(注释见下文在指定位置添加多个元素)
public boolean addAll(int index, Collection<? extends E> c);

4、添加单个元素

// 添加单个元素到链表尾部
public boolean add(E e) {
    // 添加单个元素到链表尾部
    linkLast(e);
    return true;
}

// 添加单个元素到链表尾部
void linkLast(E e) {
    final Node<E> l = last;
    // 创建一个前驱节点是尾结点，后继节点是null的节点
    final Node<E> newNode = new Node<>(l, e, null);
    // 把尾结点指向新建的节点
    last = newNode;
    // 判断l是否为空(是不是第一个元素)
    if (l == null)
        // 如果是空，说明第一次插，头结点也指向新节点
        first = newNode;
    else
        // 如果不为空，原尾结点的后继节点指向新节点
        l.next = newNode;
    // 元素个数+1
    size++;
    // 链表操作次数+1
    modCount++;
}

// 添加单个元素到指定位置
public void add(int index, E element) {
    // 检查要插入位置是否合法
    checkPositionIndex(index);
	// 判断是不是队尾
    if (index == size)
        // 是队尾，直接队尾插入
        linkLast(element);
    else
        // 不是队尾，从指定位置插入
        linkBefore(element, node(index));
}

// 返回指定元素索引处的（非空）节点。
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;
    }
}

// 将数据插入到succ节点之前
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    // succ前节点
    final Node<E> pred = succ.prev;
    // 新建一个前驱节点为succ前节点，数据为e,后继节点为succ节点的节点
    final Node<E> newNode = new Node<>(pred, e, succ);
    // 将succ的前驱节点指向新节点
    succ.prev = newNode;
    // 判断前驱节点是否为空
    if (pred == null)
        // 说明头节点也是空，将头结点指向新节点
        first = newNode;
    else
        // 不为空，将前节点的后继节点指向新节点
        pred.next = newNode;
    // 元素个数+1
    size++;
    // 链表操作次数+1
    modCount++;
}


// 检查元素索引是否合法
private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

// 判断参数是否是现有元素的索引。
private boolean isElementIndex(int index) {
    return index >= 0 && index < size;
}
   
// 检查当前位置做操作是否合法
private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

// 判断参数是否是迭代器或添加操作的有效位置的索引
private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}

5、添加多个元素

// 从尾部插入多个元素
public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}

// 从指定位置插入多个元素
public boolean addAll(int index, Collection<? extends E> c) {
    // 检查插入位置是否合法
    checkPositionIndex(index);
    Object[] a = c.toArray();
    // 插入元素个数
    int numNew = a.length;
    // // 如果无添加元素，直接返回 false 
    if (numNew == 0)
        return false;
	// 获取index所在节点及其前驱节点
    Node<E> pred, succ; 	
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }
	// 遍历数组，将其加到index前驱节点的后面
    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
        // 创建一个前驱节点是pred,数据是e,后继节点为null的新节点
        Node<E> newNode = new Node<>(pred, e, null);
        // 如果前驱节点为空
        if (pred == null)
            // 头节点指向新节点
            first = newNode;
        // 如果前驱节点不为空
        else
            // 前驱节点的后继节点指向新节点
            pred.next = newNode;
        // 前驱节点指向新节点
        pred = newNode;
    }
	
    // 如果当前节点为空，说明查到队尾了
    if (succ == null) {
        // 尾结点指向最后一个节点
        last = pred;
    // 如果当前节点不为空    
    } else {
        // 则需要将新前驱节点的后继节点指向当前节点
        pred.next = succ;
        // 将当前节点的前驱节点指向新的前驱节点
        succ.prev = pred;
    }

    // 元素个数+numNew
    size += numNew;
    // 操作次数+1
    modCount++;
    return true;
}

6、删除单个元素

// 删除链表第一个元素，并返回其结果(实现 Queue 接口)
public E remove() {
    return removeFirst();
}

// 从此列表中删除并返回第一个元素(链表为空，抛 NoSuchElementException 异常)
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

// 删除链表的第一个节点
private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    final E element = f.item;
    final Node<E> next = f.next;
    // 第一个节点值置空(方便GC)
    f.item = null;
    // 第一个节点的后继节点置空(方便GC)
    f.next = null; // help GC
    // 将头结点只向他的后继节点
    first = next;
    // 如果后继节点为空
    if (next == null)
        // 尾指针指向空
        last = null;
    // 若不为空
    else
        // 将新头结点的前驱节点置空
        next.prev = null;
    // 元素个数-1
    size--;
    // 操作次数+1
    modCount++;
    // 返回数据
    return element;
}


// 删除指定位置的元素
public E remove(int index) {
    // 检查指定位置是否合法
    checkElementIndex(index);
    return unlink(node(index));
}

// 删除当前节点
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;
        // 同时将该节点的后继节点置空
        x.prev = null;
    }
	// 如果其后继节点为空
    if (next == null) {
        // 说明被移除的是尾节点，则将尾指针指向前驱节点
        last = prev;
    // 若不为空    
    } else {
        // 后继节点的前驱指向前驱节点
        next.prev = prev;
        // 当前节点的后继置空
        x.next = null;
    }
	// 当前节点的值置空(GC)
    x.item = null;
    // 元素个数-1
    size--;
    // 操作次数+1
    modCount++;
    return element;
}

// 删除链表中第一次出现的指定元素
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;
}

7、查询操作

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

// 设置指定位置元素,并返回旧值
public E set(int index, E element) {
    // 指定位置合法性校验
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

// 返回此列表中指定元素第一次出现的索引(for循环遍历)，如果此列表不包含该元素，则返回 -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;
}

8、迭代器

//linkedList.iterator();

// List.java
Iterator<E> iterator();

// AbstractSequentialList.java
public Iterator<E> iterator() {
    return listIterator();
}

// AbstractList.java
public ListIterator<E> listIterator() {
    return listIterator(0);
}

// LinkedList.java
public ListIterator<E> listIterator(int index) {
    // 下标位置是否合法
    checkPositionIndex(index);
    return new ListItr(index);
}

// 具体实现
private class ListItr implements ListIterator<E> {
    // 最后返回的节点
    private Node<E> lastReturned;
    // 下一个节点
    private Node<E> next;
    // 下一个要访问的元素下标，从0开始
    private int nextIndex;
    // 创建迭代器时候数组操作次数(用于比较操作过程中数组是否发生变化)
    private int expectedModCount = modCount;

    // 构造器
    ListItr(int index) {
        // assert isPositionIndex(index);
        // 获取下一个节点
        next = (index == size) ? null : node(index);
        // 下一个节点位置
        nextIndex = index;
    }

    // 判断是否存在下一个节点
    public boolean hasNext() {
        return nextIndex < size;
    }

    // 获取下一个节点
    public E next() {
        // 检查数组是否发生变化了
        checkForComodification();
        // 判断是否存在下一个节点
        if (!hasNext())
            throw new NoSuchElementException();
		// 更新最后返回节点
        lastReturned = next;
        // 更新下一个节点
        next = next.next;
        // 更新下一个节点位置
        nextIndex++;
        // 返回数据
        return lastReturned.item;
    }

    // 判断是否存在前一个节点
    public boolean hasPrevious() {
        return nextIndex > 0;
    }

    // 获取前一个节点
    public E previous() {
        // 检查数组是否发生变化了
        checkForComodification();
        // 判断是否存在前一个节点
        if (!hasPrevious())
            throw new NoSuchElementException();
		// 更新最后返回节点
        lastReturned = next = (next == null) ? last : next.prev;
        // 更新下一个节点位置
        nextIndex--;
        // 返回数据
        return lastReturned.item;
    }

    // 下一个访问元素的位置
    public int nextIndex() {
        return nextIndex;
    }

    // 上一个访问元素的位置
    public int previousIndex() {
        return nextIndex - 1;
    }

    // 移除当前位置元素
    public void remove() {
        // 检查数组是否发生变化了
        checkForComodification();
        // 判断最后返回的节点是否为空
        if (lastReturned == null)
            throw new IllegalStateException();
		// 获取最后返回节点的下一个节点
        Node<E> lastNext = lastReturned.next;
        // 移除最后返回的节点
        unlink(lastReturned);
        // 这里有两种情况
        // 说明发生过调用 `#previous()` 方法的情况，next 指向下一个节点，而 nextIndex 是无需更改的
        if (next == lastReturned)
            next = lastNext;
        else
            // 更新下一个访问元素的位置
            nextIndex--;
        // 将上一个返回元素置空
        lastReturned = null;
        // 数组操作次数+1
        expectedModCount++;
    }

    // 设置当前位置元素的值
    public void set(E e) {
        // 如果 lastReturned 为空
        if (lastReturned == null)
            throw new IllegalStateException();
        // 检查数组是否发生变化
        checkForComodification();
        // 更新值
        lastReturned.item = e;
    }
	
    // 添加元素至当前位置
    public void add(E e) {
        // 检查数组是否发生变化
        checkForComodification();
        // 设置 lastReturned 为空
        lastReturned = null;
        // 此处，会分成两种情况
        // 如果 next 已经遍历到尾，则 e 作为新的尾节点，进行插入。
        if (next == null)
            linkLast(e);
        else
            // 插入到next节点之前
            linkBefore(e, next);
        // 更新下一个要访问的元素下标
        nextIndex++;‘
        // 操作数+1
        expectedModCount++;
    }

    // 对集合中剩余的元素进行操作
    public void forEachRemaining(Consumer<? super E> action) {
        // 判空
        Objects.requireNonNull(action);
        // 遍历链表剩余元素
        while (modCount == expectedModCount && nextIndex < size) {
            // 对剩余元素执行操作
            action.accept(next.item);
            // 更新最后返回节点
            lastReturned = next;
            // 更新下一个返回节点
            next = next.next;
            // 更新下一个要访问的元素下标
            nextIndex++;
        }
        // 检查数组是否发生变化了
        checkForComodification();
    }

    // 检查数组是否发生变化了
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

// 删除非空节点
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;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

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