内功心法 -- 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>