Java8源码阅读(2) ---LinkedList

一切仅在代码里，有错误欢迎指出

package org.utils.MyCollection;

import sun.awt.image.ImageWatched;

import java.util.*;
import java.util.function.Consumer;

/**
 * 重写源码LinkedList
 */
public class MyLinkedList<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;

    /**
     * 空构造函数
     */
    public MyLinkedList() {

    }

    /**
     * 从给定集合构造
     * @param c
     */
    public MyLinkedList(Collection<? extends E> c) {
        this();
        addAll(c); //添加集合中得所有元素
    }

    /**
     * 把e作为第一个节点
     * @param e
     */
    private void linkFirst(E e) {
        final Node<E> f = first;
        // 创建一个新结点，其前一个结点为null，结点值为null，后一个结点为f，原来得first结点变为第二个结点
        final Node<E> newNode = new Node<>(null, e, f);
        //新结点变为first结点
        first = newNode;
        // 如果原来first为null，那么新结点同时也是last结点，此时链表只有一个结点
        if (f == null)
            last = newNode;
        // 否则第二个结点得前向指针指向第一个结点
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

    /**
     * 添加一个新结点为尾结点
     * @param e
     */
    private void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

    /**
     * 在非空结点succ之前添加结点e
     * @param e 新结点
     * @param succ 非空结点
     */
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        // succ得前向指针指向得结点记为pred
        final Node<E> prev = succ.prev;
        // 创建一个新结点，其前向指针指向pred，后向指针指向succ
        final Node<E> newNode = new Node<>(prev, e, succ);
        // 断开succ指向pred得前向指针，并将其指向newNode
        succ.prev = newNode;
        if (prev == null)
            first = newNode;
        else
            // 修改后向指针
            prev.next = newNode;
        size++;
        modCount++;
    }

    /**
     * 释放头结点
     * 删除列表得头结点，并返回结点值
     * @param f
     * @return 头结点值
     */
    private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null
        // 保存结点值
        final E element = f.item;
        // 保存头结点的下一个结点
        final Node<E> next = f.next;
        // 头结点前后指针置空
        f.item = null;
        f.next = null;
        // 将原来的第二个结点变为first
        first = next;
        // 如果原来的第二个结点是null，即原来只有一个结点
        if (next == null)
            last = null;
        else
            // 新头结点的前向指针应为null
            next.prev = null;
        // 元素数量减一
        size--;
        modCount++;
        return element;
    }

    /**
     * 释放尾结点
     * @param l
     * @return 尾结点值
     */
    private E unlinkLast(Node<E> l) {
        // assert l == last && l != null
        final E element = l.item;
        final Node<E> prev = l.prev;
        l.prev = null;
        l.next = null;
        last = prev;
        if (last == null)
            first = null;
        else
            last.next = null;
        size--;
        modCount++;
        return element;
    }

    /**
     * 释放任意结点x，返回结点的值
     * @param x
     * @return x结点值
     */
    E unlink(Node<E> x) {
        // assert x != null
        //保留x的结点值，前向结点和后向结点
        final E element = x.item;
        final Node<E> prev = x.prev;
        final Node<E> next = x.next;
        // 如果x的前向结点为null，说明x为first
        // 此时删除x后，first变为x的next
        if (prev == null) {
            first = next;
        }
        else {
            prev.next = next;
            x.prev = null;
        }
        // 如果x的后向结点为null，说明x为last
        // 此时删除x后，last变为x的前向结点
        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }
        x.item = null;
        size--;
        modCount++;
        return element;
    }

    /**
     * 返回头结点的值
     * @return 头结点值
     * @throws NoSuchElementException
     */
    public E getFirst() {
        final Node<E> f = first;
        if (f == null) {
            throw new NoSuchElementException();
        }
        return f.item;
    }

    /**
     * 返回尾结点的值
     * @return 尾结点值
     * @throws NoSuchElementException
     */
    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

    /**
     * 删除头结点，并返回结点值
     * @return 结点值
     */
    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

    /**
     * 删除尾结点
     * @return 结点值
     */
    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

    /**
     * 添加头结点
     * @param e
     */
    public void addFirst(E e) {
        linkFirst(e);
    }

    /**
     * 添加尾结点
     * @param e
     */
    public void addLast(E e) {
        linkLast(e);
    }