内功心法 -- java.util.LinkedList<E> (8)

写在前面的话：读书破万卷，编码如有神
--------------------------------------------------------------------
下文主要对java.util.LinkedList<E>的Iterator操作和数组、克隆操作进行介绍，主要内容包括：

1、LinkedList常用的Iterator操作介绍

2、LinkedList常用的数组和克隆操作进行介绍

参考内容：

1、JDK源码(1.7)

--------------------------------------------------------------------

1、LinkedList常用的Iterator操作介绍

(1) ListIterator<E> listIterator(int index)

功能: 返回此双端队列的ListIterator对象

源代码如下:

    /*
        返回此双端队列的ListIterator对象
    */
    public ListIterator<E> listIterator(int index) {
        //检查参数index是合法
        checkPositionIndex(index);
        //创建一个ListItr对象
        return new ListItr(index);
    }

    /*
        内部类ListItr
    */
    private class ListItr implements ListIterator<E> {
        //记录最后一次返回的Node节点
        private Node<E> lastReturned = null;
        //记录下一次要返回的Node节点
        private Node<E> next;
        //记录下一次要返回Node节点的索引
        private int nextIndex;
        //fast-fail机制
        private int expectedModCount = modCount;
        
        //构造函数
        ListItr(int index) {
            // assert isPositionIndex(index);
            next = (index == size) ? null : node(index);
            nextIndex = index;
        }

        //判断是否还有下一个节点
        public boolean hasNext() {
            return nextIndex < size;
        }
        
        //返回下一个Node节点
        public E next() {
            //检查fast-fail机制
            checkForComodification();
            //如果没有下一个节点了，则抛出异常
            if (!hasNext())
                throw new NoSuchElementException();
            //记录最后返回的节点
            lastReturned = next;
            //指向下一个节点
            next = next.next;
            //索引下标加1
            nextIndex++;
            //返回节点
            return lastReturned.item;
        }

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

        //返回上一个Node节点
        public E previous() {
            //检查fast-fail机制
            checkForComodification();
            //如果没有上一个节点了，则抛出异常
            if (!hasPrevious())
                throw new NoSuchElementException();
            //记录最后返回的节点
            lastReturned = next = (next == null) ? last : next.prev;
            //索引下标减1
            nextIndex--;
            //返回节点
            return lastReturned.item;
        }

        //返回下一个返回节点的索引下标
        public int nextIndex() {
            return nextIndex;
        }

         //返回上一个返回节点的索引下标
        public int previousIndex() {
            return nextIndex - 1;
        }

        //删除最后返回的Node节点
        public void remove() {
            //检查fast-fail机制
            checkForComodification();
            //如果没有返回过Node节点，则抛出异常
            if (lastReturned == null)
                throw new IllegalStateException();

            //删除节点，并且重新设置连接
            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;
        }

        //将最后返回的Node节点的值设置为e
        public void set(E e) {
            if (lastReturned == null)
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.item = e;
        }

        //将元素e添加到此双端队列中
        public void add(E e) {
            //检查fast-fail机制
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }
        //检查fast-fail机制
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

(2) Iterator<E> descendingIterator()

功能: 返回此双端队列的Iteraotr对象（逆序）

源代码如下:

    /*
        功能: 返回此双端队列的Iterator对象（逆序）
    */
    public Iterator<E> descendingIterator() {
        //创建一个DescendingIterator对象
        return new DescendingIterator();
    }

    /**
     * 返回此双端队列的Iterator对象（逆序）
     */
    private class DescendingIterator implements Iterator<E> {
        //创建一个ListItr对象
        private final ListItr itr = new ListItr(size());

        //判断是否还有下一个元素
        public boolean hasNext() {
            //逆序
            return itr.hasPrevious();
        }

        //返回下一个元素
        public E next() {
            return itr.previous();
        }

        //删除元素
        public void remove() {
            itr.remove();
        }
    }

--------------------------------------------------------------------

2、LinkedList常用的数组和克隆操作进行介绍

(1) Object clone()

功能: 复制此双端队列的对象

源代码如下:

    /*
       返回一个此双端队列的浅复制
    */
    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;
    }

    /*
       返回一个此双端队列的浅复制
    */
    @SuppressWarnings("unchecked")
    private LinkedList<E> superClone() {
        try {
            return (LinkedList<E>) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }

(2) Object[] toArray()

功能: 将此双端队列中的元素以数组的形式返回

源代码如下:

    /*
       将此双端队列中的元素以数组的形式返回
    */
    public Object[] toArray() {
        //创建一个Object类型的数组
        Object[] result = new Object[size];
        int i = 0;
        //循环为数组赋值
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
        return result;
    }

(3) T[] toArray(T[] a)

功能: 将此双端队列中的元素以数组的形式返回

源代码如下:

    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        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;

        if (a.length > size)
            a[size] = null;

        return a;
    }

--------------------------------------------------------------------

java.util.LinkedList<E>系列文章                                            

java.util.LinkedList<E>(1)　　java.util.LinkedList<E>(2)　　java.util.LinkedList<E>(3)

java.util.LinkedList<E>(4)　　java.util.LinkedList<E>(5)　　java.util.LinkedList<E>(6)

java.util.LinkedList<E>(7)　　java.util.LinkedList<E>(8)　　

--------------------------------------------------------------------

相关知识                                                                             

java.util.Collection<E> 　　java.util.AbstractCollection<E> 　　java.util.List<E>

java.util.AbstractList<E> 　　java.util.Iterator<E> 　　java.util.ListIterator<E>

Java中的标记接口 　　迭代器模式 　　Java中的深拷贝和浅拷贝  java.util.Arrays

java.util.Queue<E>　　java.util.Deque<E>