java源码解读之LinkedList

package java.util;

import java.util.function.Consumer;

/**
 * 通过LinkedList的继承和实现的类与接口,可以看出:
 * 由于继承了AbstractSequentialList的双向链表,因此可以被当作堆栈、队列或双端队列进行操作
 * 实现 List 接口,能对它进行队列操作
 * 实现 Deque 接口,即能将LinkedList当作双端队列使用
 * 实现了Cloneable接口,即覆盖了函数clone(),能进行拷贝
 * 实现java.io.Serializable接口,这意味着LinkedList支持序列化,能通过序列化去传输
 */

public class LinkedList<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;

    /**
     * 构造一个空的LinkedList对象
     */
    public LinkedList() {
    }

    /**
     * 使用指定集合里面的元素构造一个LinkedList对象,
     * 该集合为null的时候抛NullPointerException异常
     */
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

    /**
     * 将指定元素e作为链表的头节点
     */
    private void linkFirst(E e) {
        final Node<E> f = first;
        //元素e生成新节点对象
        final Node<E> newNode = new Node<>(null, e, f);
        //将链表头节点指针指向新节点
        first = newNode;
        //若链表头结点为null,说明该链表原来为空,将链表尾节点指针也指向新节点
        if (f == null)
            last = newNode;
        else//若该链表原来不为空,将旧头结点的前指针指向新节点
            f.prev = newNode;
        //链表元素数量+1
        size++;
        //链表结构修改次数+1
        modCount++;
    }

    /**
     * 将指定元素e作为链表的尾节点
     */
    void linkLast(E e) {
        final Node<E> l = last;
        //元素e生成新节点对象
        final Node<E> newNode = new Node<>(l, e, null);
        //将链表尾节点指针指向新节点
        last = newNode;
        //若链表尾节点为null,说明该链表原来为空,将链表头节点指针也指向新节点
        if (l == null)
            first = newNode;
        else//若该链表原来不为空,将旧尾结点的后指针指向新节点
            l.next = newNode;
        //链表元素数量+1
        size++;
        //链表结构修改次数+1
        modCount++;
    }

    /**
     * 将元素e插入到指定不为null的元素succ之前,要完成的步骤一共有3个:
     * 1.保存succ元素的前节点对象
     * 2.将succ元素的前指针指向新节点对象
     * 3.将succ元素的前节点对象的后指针指
     * 向新节点对象,若succ元素时头结点则将
     * 头节点指向新节点对象
     */
    void linkBefore(E e, Node<E> succ) {
        final Node<E> pred = succ.prev;
        //元素e生成新节点对象,该节点的前指针指向succ的前节点,后指针指向succ
        final Node<E> newNode = new Node<>(pred, e, succ);
        //将succ的前指针指向元素e对应的节点
        succ.prev = newNode;
        //若succ的前指针指向的节点为null,说明succ为头节点,应将头节点指针指向新节点对象
        if (pred == null)
            first = newNode;
        else//若succ的前指针指向的节点不为null,则将succ的前指针指向的节点的后指针指向新节点
            pred.next = newNode;
        //链表元素数量+1
        size++;
        //链表结构修改次数+1
        modCount++;
    }

    /**
     * 将非null的头节点f从链表中断开,应确保f为头结点且不为null
     */
    private E unlinkFirst(Node<E> f) {
       //存放头结点的元素
        final E element = f.item;
        //存放第二个节点
        final Node<E> next = f.next;
        //将头节点的元素与后指针清空,将引用指向null可帮助GC快速回收内存
        f.item = null;
        f.next = null;
        //将第二个节点作为头节点
        first = next;
        //若第二个节点为null,说明该链表原来只有一个节点,则尾节点置为null
        if (next == null)
            last = null;
        else//若第二个节点不为null,其作为头结点,前指针应指向null
            next.prev = null;
        //链表元素数量-1
        size--;
        //链表结构修改次数+1
        modCount++;
        return element;
    }

    /**
     * 将非null的尾节点l从链表中断开,应确保l为尾结点且不为null
     */
    private E unlinkLast(Node<E> l) {
    	//存放尾节点的元素
        final E element = l.item;
        //存放尾节点的上一个节点(倒数第二个节点)
        final Node<E> prev = l.prev;
        //将尾节点的元素与前指针清空,将引用指向null可帮助GC快速回收内存
        l.item = null;
        l.prev = null; 
        //将倒数第二个节点作为尾节点
        last = prev;
      //若倒数第二个节点为null,说明该链表原来只有一个节点,则头节点置为null
        if (prev == null)
            first = null;
        else//若倒数第二个节点不为null,其作为尾节点,后指针应指向null
            prev.next = null;
        //链表元素数量-1
        size--;
        //链表结构修改次数+1
        modCount++;
        return element;
    }

    /**
     * 将非null的节点x从链表中断开,应保证节点x不为null
     */
    E unlink(Node<E> x) {
    	//存放节点x的元素
        final E element = x.item;
        //存放节点x的下一个节点
        final Node<E> next = x.next;
        //存放节点x的上一个节点
        final Node<E> prev = x.prev;
        /**------------这里开始处理节点x的上一个节点的指向关系------------**/
        if (prev == null) {
            /**若节点x的上一个节点为null,说明节点x为头节点,则头节点
             * 指针指向节点x的下一个节点,即完成从 x↔B↔C 到 B↔C 的转变
             */
            first = next;
        } else {
        	/**
        	 * 若节点x不是头节点,则将节点x的上一个节点的后指针指向节点x的下一个节点,
        	 * 并将节点x的前指针置为null,即完成从 A↔x↔C 到A→C 的转变  
        	 */
            prev.next = next;
            x.prev = null;
        }
        /**-------------处理节点x的上一个节点的指向关系结束-------------**/
        /**------------这里开始处理节点x的下一个节点的指向关系------------**/
        if (next == null) {
        	/**
        	 * 若节点x的下一个节点为null,说明节点x为尾节点,则尾节点指
        	 * 针指向节点x的上一个节点,即完成从 B↔C↔x 到B↔C 的转变
        	 */
            last = prev;
        } else {
        	/**
        	 * 若节点x不是尾节点,则将节点x的下一个节点的前指针指向节点x的上一个节点,
        	 * biang将节点x的后指针置为null,即完成从 A↔x↔C 到A←C 的转变
        	 */
            next.prev = prev;
            x.next = null;
        }
        /**-------------处理节点x的下一个节点的指向关系结束-------------**/
        //经过上面两部分对节点x的处理,完成了从 A↔x↔C 到A↔C 的转变
        //将节点x的元素置为null,释放内存
        x.item = null;
        //链表元素数量-1
        size--;
        //链表结构修改次数+1
        modCount++;
        return element;
    }

    /**
     * 获取链表的第一个元素并返回
     */
    public E getFirst() {
    	//取得链表的头节点
        final Node<E> f = first;
        if (f == null)
        	//若头节点为null,则抛NoSuchElementException
            throw new NoSuchElementException();
        //否则返回头结点的元素
        return f.item;
    }

    /**
     *获取链表最后一个元素并返回
     */
    public E getLast() {
    	//取得链表的最后一个元素
        final Node<E> l = last;
        if (l == null)
        	//若尾节点为null,则抛NoSuchElementException
            throw new NoSuchElementException();
        //否则返回尾节点的元素
        return l.item;
    }

    /**
     * 移除并返回链表的第一个元素
     */
    public E removeFirst() {
    	//取得链表的第一个元素
        final Node<E> f = first;
        if (f == null)
        	//若头节点为null,则抛NoSuchElementException
            throw new NoSuchElementException();
        //断开头结点与链表的关系并返回头节点元素
        return unlinkFirst(f);
    }

    /**
     *移除并返回链表最后一个元素
     */
    public E removeLast() {
    	//取得链表的最后一个元素
        final Node<E> l = last;
        if (l == null)
        	//若尾节点为null,则抛NoSuchElementException
            throw new NoSuchElementException();
      //断开尾结点与链表的关系并返回尾节点元素
        return unlinkLast(l);
    }

    /**
     *将指定元素e做为头节点加入链表
     */
    public void addFirst(E e) {
        linkFirst(e);
    }

    /**
     * 将指定元素e作为尾节点加入链表
     */
    public void addLast(E e) {
        linkLast(e);
    }

    /**
     * 判断链表中是否包含指定元素o,包含返回true,否则返回false
     */
    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }

    /**
     * 返回链表的元素个数
     */
    public int size() {
        return size;
    }

    /**
     * 将元素e加入链表,默认加入链表尾部
     */
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    /**
     * 从链表中移除第一个与指定元素o相等的元素,逻辑与判断元素o在链表的位置大体一样
     */
    public boolean remove(Object o) {
        if (o == null) {
        	//若元素o为null,则遍历链表并将第一个为null的元素从链表中移除
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
        	//若元素o不为null,则遍历链表并使用equals方法比较元素,若匹配则移除对应的元素
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 将指定集合c中的元素添加到链表的尾部
     */
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

    /**
     *将指定集合c中的元素从index开始添加到链表
     */
    public boolean addAll(int index, Collection<? extends E> c) {
    	//检查index是否有效,不是则抛IndexOutOfBoundsException
        checkPositionIndex(index);
        //将集合中的元素转换为Object数组
        Object[] a = c.toArray();
        int numNew = a.length;
        //若该集合的元素个数为0,则添加失败,返回false
        if (numNew == 0)
            return false;

        Node<E> pred, succ;
        if (index == size) {
        	//若index为链表的最后末尾,则succ为null,pred指向尾节点
            succ = null;
            pred = last;
        } else {
        	//否则,succ指向链表index位置上的节点,pred为succ的上一个节点
            succ = node(index);
            pred = succ.prev;
        }
        //遍历Object数组并将元素添加到链表中
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            //元素o生成新节点newNode
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null)
            	//若pred为null,则说明index为头结点位置,Object数组的第一个元素作为头节点
            	//即完成 succ↔A↔B 到 o1↔o2↔o3↔...↔succ↔A↔B 的转变 
                first = newNode;
            else
            	//否则index位置上一个节点的后指针指向新节点
            	//即完成pred↔succ↔A 到 pred↔o1↔o2↔o3↔...↔succ↔A 的转变
                pred.next = newNode;
            //最后pred的指针指向新节点,遍历到最后,pred指向的会是Object数组的最后一个元素对应的节点
            pred = newNode;
        }
        //若succ为null,表明index为链表末尾,尾节点指向pred节点(此时pred指向的是Object数组最后一个元素对应的节点)
        if (succ == null) {
            last = pred;
        } else {
        	//否则index处理链表中间位置,pred的后指针(此时pred指向的是
        	//Object数组最后一个元素对应的节点)指向succ节点,succ的前
        	//指针指向pred节点
            pred.next = succ;
            succ.prev = pred;
        }
        //链表元素数量+numNew
        size += numNew;
        //链表结构修改次数+1
        modCount++;
        return true;
    }

    /**
     *清除链表中的所有节点
     */
    public void clear() {
    	//遍历链表直接将节点置为null即可
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        //最后头结点与尾节点也置为null
        first = last = null;
        //链表元素个数置为0
        size = 0;
        //链表结构修改次数+1
        modCount++;
    }


    // Positional Access Operations

    /**
     * 获取链表中指定index位置上的元素
     */
    public E get(int index) {
    	//判断该index位置是否为有效位置,不是则抛IndexOutOfBoundsException
        checkElementIndex(index);
        //返回index位置上节点的元素
        return node(index).item;
    }

    /**
     * 将链表指定index位置上的元素替换为新的element
     */
    public E set(int index, E element) {
    	//判断该index位置是否为有效位置,不是则抛IndexOutOfBoundsException
        checkElementIndex(index);
        //获取index位置上的节点
        Node<E> x = node(index);
        //存放该节点老的元素
        E oldVal = x.item;
        //将新的element设置到index节点中
        x.item = element;
        //返回index节点老的元素
        return oldVal;
    }

    /**
     * 将element元素插入到链表的指定位置
     */
    public void add(int index, E element) {
    	//判断该index位置是否为有效位置,不是则抛IndexOutOfBoundsException
        checkPositionIndex(index);
        //若该位置index为最后一个位置,则element直接添加到链表末尾
        if (index == size)
            linkLast(element);
        else
        	//否则,获取该位置上的节点,并将element添加到该节点之前
            linkBefore(element, node(index));
    }

    /**
     * 移除链表指定index位置上的节点
     */
    public E remove(int index) {
    	//判断该index位置是否为有效位置,不是则抛IndexOutOfBoundsException
        checkElementIndex(index);
        //获取index位置上的节点并从链表中断开
        return unlink(node(index));
    }

    /**
     * 判断指定下标是否为有效的位置
     */
    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    /**
     * 判断指定下标是否为有效的位置
     */
    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

    /**
     *构造IndexOutOfBoundsException的描述信息
     */
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

    private void checkElementIndex(int index) {
    	//若该下标index不是有效的位置,则抛IndexOutOfBoundsException
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private void checkPositionIndex(int index) {
    	//若该下标index不是有效的位置,则抛IndexOutOfBoundsException
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * 返回链表中指定下标的节点
     */
    Node<E> node(int index) {
    	//比较index与size >> 1,这样的好处是使得获取链表的任意位置节点至多只需遍历链表长度的1/2,提高效率
        //将size/2,若index<size/2,则说明index分布在链表的左半部分,
        if (index < (size >> 1)) {
        	//则从左到右遍历链表去获取节点并返回
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
        	//若index分布在链表的右半部分,则从右到左遍历链表去获取节点并返回
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

    // Search Operations

    /**
     *返回指定元素o在链表中的下标,若元素o不在链表中则返回-1
     */
    public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
        	//若元素o为null,则遍历链表并返回链表中第一个为null的元素的下标
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
        	//若元素o不为null,则遍历链表并使用equals方法比较元素,若相等则返回对应的下标
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        //遍历完链表皆未找到匹配的元素,则返回-1
        return -1;
    }

    /**
     * 返回链表中最后一个与给定对象o相等的元素的位置,与indexOf方法逻辑大体一致,只是遍历方向是从右到左而已
     */
    public int lastIndexOf(Object o) {
        int index = size;
        if (o == null) {
        	//若o为null,则从右到左遍历,返回第一个为null的元素的下标
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (x.item == null)
                    return index;
            }
        } else {
        	//若o不为null,则从右到左遍历,使用equals方法比较,返回第一个与o相等的元素的下标
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (o.equals(x.item))
                    return index;
            }
        }
        //若没有则返回-1
        return -1;
    }

    // Queue operations.

    /**
     * 返回链表第一个元素,不从链表中移除,若不存在则返回null
     */
    public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }

    /**
     * 返回链表的第一个元素,若不存在则抛NoSuchElementException
     */
    public E element() {
        return getFirst();
    }

    /**
     * 弹出(移除)并返回链表的第一个元素,若不存在则返回null
     */
    public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

    /**
     * 移除并返回链表的第一个元素,若不存在则抛NoSuchElementException
     */
    public E remove() {
        return removeFirst();
    }

    /**
     * 插入指定元素e到链表末尾
     */
    public boolean offer(E e) {
        return add(e);
    }

    // Deque operations
    /**
     * 插入指定元素e到链表的头部
     */
    public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

    /**
     * 插入指定元素e到链表的末尾
     */
    public boolean offerLast(E e) {
        addLast(e);
        return true;
    }

    /**
     * 获取链表的第一个元素(不移除),若不存在则返回null
     */
    public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }

    /**
     * 获取链表的最后一个元素(不移除),若不存在则返回null
     */
    public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }

    /**
     * 弹出(移除)链表的第一个元素并返回,若不存在则返回null
     */
    public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

    /**
     * 弹出(移除)链表的最后一个元素并返回,若不存在则返回null
     */
    public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }

    /**
     * 将指定元素e放入链表的头部
     */
    public void push(E e) {
        addFirst(e);
    }

    /**
     * 弹出(移除)链表的第一个元素
     */
    public E pop() {
        return removeFirst();
    }

    /**
     * 移除链表中第一个与指定元素o相等的元素,若不存在则链表保持不变
     */
    public boolean removeFirstOccurrence(Object o) {
        return remove(o);
    }

    /**
     * 移除链表中最后一个与元素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;
    }

    /**
     * 返回一个可以指定起始位置的列表迭代器,在迭代器创建之后,如果链表的结构上发生改变(使用
     * 迭代器自身的方法除外),将会抛出ConcurrentModificationException
     */
    public ListIterator<E> listIterator(int index) {
    	//检查index是否有效,无效则抛IndexOutOfBoundsException
        checkPositionIndex(index);
        //创建List迭代器并返回
        return new ListItr(index);
    }

    private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned;//记录迭代器最后一个返回的节点,用于迭代器回溯到上一个节点
        private Node<E> next;//记录迭代器当前迭代的下一个节点
        private int nextIndex;//记录迭代器下一个节点的下标位置
        private int expectedModCount = modCount;//记录当前迭代器修改次数

        /**
         * 从指定index位置开始构造一个List迭代器
         */
        ListItr(int index) {
        	//若index是链表的末尾,则next指向null,否则指向其所在位置的节点
            next = (index == size) ? null : node(index);
            nextIndex = index;
        }

        //判断迭代器是否有后继节点,未到达链表末尾前皆返回true
        public boolean hasNext() {
            return nextIndex < size;
        }

        public E next() {
        	//检查当前迭代器与链表结构上是否一致,不一致则抛ConcurrentModificationException
            checkForComodification();
            //若不存在下一个元素而调用next方法则会抛NoSuchElementException
            if (!hasNext())
                throw new NoSuchElementException();
            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }

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

        //返回当前位置的上一个节点,此时lastReturned的作用便显现了
        public E previous() {
        	//检查当前迭代器与链表结构上是否一致,不一致则抛ConcurrentModificationException
            checkForComodification();
            //若不存在上一个元素而调用next方法则会抛NoSuchElementException
            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() {
        	//检查当前迭代器与链表结构上是否一致,不一致则抛ConcurrentModificationException
            checkForComodification();
            //当lastRetured为null,则表示当前迭代器处于非法状态,抛IllegalStateException
            if (lastReturned == null)
                throw new IllegalStateException();
            //记录下一个节点
            Node<E> lastNext = lastReturned.next;
            //将当前节点从链表中移除,此操作会导致链表的结构修改次数+1
            unlink(lastReturned);
            /**当上一次的操作是previous的时候,next与lastRetured会指向同一个节点,
             *此时删除了lastReturned节点时,next便会为null,此时需要将lastRetured
             *的下一个节点赋予next
            */
            if (next == lastReturned)
                next = lastNext;
            else
            	//否则nextIndex倒退1个位置
                nextIndex--;
            lastReturned = null;
            //将当前迭代器的结构修改次数也+1,因此调用迭代器自己的remove或add方法不会抛ConcurrentModificationException
            expectedModCount++;
        }

        //将当前迭代到的元素设置为指定元素e
        public void set(E e) {
        	//若当前元素节点为null,则抛IllegalStateException
            if (lastReturned == null)
                throw new IllegalStateException();
            //检查当前迭代器与链表结构上是否一致,不一致则抛ConcurrentModificationException
            checkForComodification();
            lastReturned.item = e;
        }

        //添加指定元素到链表中
        public void add(E e) {
        	//检查当前迭代器与链表结构上是否一致,不一致则抛ConcurrentModificationException
            checkForComodification();
            lastReturned = null;
            //若next为null,则表示迭代到了尾节点,直接插入到链表最后即可
            if (next == null)
                linkLast(e);
            else
            	//否则将元素e插入到当前位置
                linkBefore(e, next);
            nextIndex++;
            //因为linkLast方法与linkBefore方法会导致链表结构修改次数+1,
            //因此当前迭代器的结构修改次数也应随之+1,才不会抛ConcurrentModificationException
            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() {
        	/**
        	 * 若不一致则抛ConcurrentModificationException,因此在使用迭代器之外
        	 * 的方法对链表进行结构上的操作造成modCount修改次数发生变化,迭代器便会抛
        	 * ConcurrentModificationException
        	 */
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    /**
     * 链表节点的封装类
     * @author linxiaorui
     *
     * @param <E>
     */
    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 Iterator<E> descendingIterator() {
        return new DescendingIterator();
    }

    /**
     * 相比于ListItr迭代器是从左到右升序迭代遍历,该迭代器是从右到左降序迭代遍历
     */
    private class DescendingIterator implements Iterator<E> {
        private final ListItr itr = new ListItr(size());
        public boolean hasNext() {
            return itr.hasPrevious();
        }
        public E next() {
            return itr.previous();
        }
        public void remove() {
            itr.remove();
        }
    }

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

    /**
     * 返回该链表保存元素的Object数组,该Object数组可以任意操作而不会影响到链表本身
     */
    public Object[] toArray() {
        Object[] result = new Object[size];
        int i = 0;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
        return result;
    }

    /**
     * 将LinkedList对象中的元素复制到传递进来的数组中
     */
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
    	//若传入数组的长度小于size,返回一个新的数组,大小为size,类型与传入数组相同
        if (a.length < size)
            a = (T[])java.lang.reflect.Array.newInstance(
                                a.getClass().getComponentType(), size);
        //遍历链表并将元素放入传进来的数组中
        int i = 0;
        Object[] result = a;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
        //数组的长度超过链表本身元素数量则最后一个位置为null
        if (a.length > size)
            a[size] = null;

        return a;
    }

    private static final long serialVersionUID = 876323262645176354L;

    /**
     * 将当前链表序列化到指定输出流
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        // Write out any hidden serialization magic
        s.defaultWriteObject();

        // Write out size
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (Node<E> x = first; x != null; x = x.next)
            s.writeObject(x.item);
    }

    /**
     *从指定输入流中把链表读出来并插入到当前链表尾部
     */
    @SuppressWarnings("unchecked")
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();

        // Read in size
        int size = s.readInt();

        // Read in all elements in the proper order.
        for (int i = 0; i < size; i++)
            linkLast((E)s.readObject());
    }

    /**
     * 创建一个基于当前LinkedList的可分割的迭代器
     */
    @Override
    public Spliterator<E> spliterator() {
        return new LLSpliterator<E>(this, -1, 0);
    }

    /** A customized variant of Spliterators.IteratorSpliterator */
    static final class LLSpliterator<E> implements Spliterator<E> {
        static final int BATCH_UNIT = 1 << 10;  // 每个数组的增长因子
        static final int MAX_BATCH = 1 << 25;  // 每个数组存放元素的最大数
        final LinkedList<E> list; // 用于存放LindedList对象
        Node<E> current;      // 存放当前节点
        int est;              // 预估规模字段,初始化默认为-1
        int expectedModCount; // 存放链表结构修改次数
        int batch;            // 记录每次分割的大小
        /** 创建一个覆盖给定范围的LinkedList可分割迭代器 */
        LLSpliterator(LinkedList<E> list, int est, int expectedModCount) {
            this.list = list;
            this.est = est;
            this.expectedModCount = expectedModCount;
        }

        //获取该迭代器的规模数
        final int getEst() {
            int s; 
            final LinkedList<E> lst;
            if ((s = est) < 0) {
            	//若传进来的linkedList为null,则规模为0
                if ((lst = list) == null)
                    s = est = 0;
                else {
                	//不为null,则强制初始化该迭代器的信息
                    expectedModCount = lst.modCount;
                    current = lst.first;
                    s = est = lst.size;
                }
            }
            return s;
        }
        //获取该迭代器的规模数
        public long estimateSize() { return (long) getEst(); }
        //该方法将根据BATCH_UNIT与MAX_BATCH两个字段信息尝试对链表进行一次分割
        public Spliterator<E> trySplit() {
            Node<E> p;
            int s = getEst();
            if (s > 1 && (p = current) != null) {
                int n = batch + BATCH_UNIT;
                if (n > s)
                    n = s;
                if (n > MAX_BATCH)
                    n = MAX_BATCH;
                Object[] a = new Object[n];
                int j = 0;
                //这里开始遍历链表进行分割并将元素放入Object数组中,直到数组元素数量达到迭代器的限制或链表遍历完
                do { a[j++] = p.item; } while ((p = p.next) != null && j < n);
                current = p;
                batch = j;
                est = s - j;//重新计算链表剩下的规模
                return Spliterators.spliterator(a, 0, j, Spliterator.ORDERED);
            }
            return null;
        }

        /**
         * 对每个剩余元素执行给定的动作,依次处理,直到所有元素已被处理或被异常终
         * 止,Spliterator中默认是循环调用tryAdvance方法
         */
        public void forEachRemaining(Consumer<? super E> action) {
            Node<E> p; int n;
            if (action == null) throw new NullPointerException();
            //当且仅当迭代器有元素才进行处理
            if ((n = getEst()) > 0 && (p = current) != null) {
                current = null;
                est = 0;
                do {
                    E e = p.item;
                    p = p.next;
                    action.accept(e);
                } while (p != null && --n > 0);
            }
            if (list.modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

        //对单个元素执行给定的动作,如果有剩下元素未处理返回true,否则返回false
        public boolean tryAdvance(Consumer<? super E> action) {
            Node<E> p;
            if (action == null) throw new NullPointerException();
            //当且仅当迭代器有元素才进行处理
            if (getEst() > 0 && (p = current) != null) {
                --est;
                E e = p.item;
                current = p.next;
                action.accept(e);
                if (list.modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                return true;
            }
            return false;
        }
        //这.........真不知是干嘛用的
        public int characteristics() {
            return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
        }
    }

}