java  IteratorインターフェースとLIstIteratorインターフェース分析

java  IteratorインターフェースとLIstIteratorインターフェース分析
目次
1.Iteratorインターフェース
2.ListIterator
3.IteratorとListIteratorの違い 
本文
ArayListのソースコードを引き続き見る前に、先にIteratorインターフェースとListIteratorインターフェースを理解して、次の文章はArayListがどのようにそれらを実現したかを詳しく説明します。
インターフェースは一つの仕様にすぎないことを知っています。インターフェースを継承し、その中の方法を実現するときは、インターフェースの方法の説明に従います。
1.Iteratorインターフェース
IteratorインターフェースはJava集合の枠組みの中のEnumeratorionに取って代わった。Iteratorsはenumerationsと違って、主に2点があります。
Iteratorsは、繰り返しの間に使用者がセットから要素を除去することを可能にする。
メソッド名が改善されました。
Iteratorソースは以下の通りです。

/**
 * An iterator over a collection. {@code Iterator} takes the place of
 * {@link Enumeration} in the Java Collections Framework. Iterators
 * differ from enumerations in two ways:
 * Iterators allow the caller to remove elements from the underlying collection during the iteration with well-defined semantics.
 * Method names have been improved.
 * This interface is a member of the Java Collections Framework.
 * @param <E> the type of elements returned by this iterator*/
public interface Iterator<E> {
  /**
   * Returns {@code true} if the iteration has more elements.
   * (In other words, returns {@code true} if {@link #next} would
   * return an element rather than throwing an exception.)
   * @return {@code true} if the iteration has more elements
   */
  boolean hasNext();

  /**
   * Returns the next element in the iteration.
   * @return the next element in the iteration
   * @throws NoSuchElementException if the iteration has no more elements
   */
  E next();

  /**
   * Removes from the underlying collection the last element returned
   * by this iterator (optional operation). This method can be called
   * only once per call to {@link #next}. The behavior of an iterator
   * is unspecified if the underlying collection is modified while the
   * iteration is in progress in any way other than by calling this
   * method.
   *
   * @implSpec
   * The default implementation throws an instance of
   * {@link UnsupportedOperationException} and performs no other action.
   *
   * @throws UnsupportedOperationException if the {@code remove}
   *     operation is not supported by this iterator
   *
   * @throws IllegalStateException if the {@code next} method has not
   *     yet been called, or the {@code remove} method has already
   *     been called after the last call to the {@code next}
   *     method
   */
  default void remove() {
    throw new UnsupportedOperationException("remove");
  }

  /**
   * Performs the given action for each remaining element until all elements
   * have been processed or the action throws an exception. Actions are
   * performed in the order of iteration, if that order is specified.
   * Exceptions thrown by the action are relayed to the caller.
   *
   * @implSpec
   * <p>The default implementation behaves as if:
   * <pre>{@code
   *   while (hasNext())
   *     action.accept(next());
   * }</pre>
   *
   * @param action The action to be performed for each element
   * @throws NullPointerException if the specified action is null
   * @since 1.8
   */
  default void forEachRemaining(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    while (hasNext())
      action.accept(next());
  }
}

Iteratorインターフェースは4つの方法及び各方法の機能を定義しています。もしこのインターフェースが実現され、これらの方法が実現された場合、この方法は定義された機能を実現する必要があります。これらの規則に従います。
1）has Next()容器に次の要素があるかどうかを判断し、あるとtrueに戻ります。
2）next()は容器の次の要素に戻ります。
3）Remove()は、現在のディケンサが返した最後の要素を削除します。この方法はnext()メソッドを呼び出すたびに一回だけ呼び出すことができます。
4）Java 8は、forEachRemaning方法を追加し、残りのすべての要素に対して指定された操作を実行することができます。
より詳細な説明はソースのコメントを読んでください。
2.ListIterator
ListIteratorは、Iteratorに基づいて、add、set、previousなどのリストに対する操作を提供しています。しかし、ListIteratorはIteratorと同じで、元のリストで操作します。
ListIteratorソースは以下の通りです。

/**
 * An iterator for lists that allows the programmer
 * to traverse the list in either direction, modify
 * the list during iteration, and obtain the iterator's
 * current position in the list. A {@code ListIterator}
 * has no current element; its <I>cursor position</I> always
 * lies between the element that would be returned by a call
 * to {@code previous()} and the element that would be
 * returned by a call to {@code next()}.
 * An iterator for a list of length {@code n} has {@code n+1} possible
 * cursor positions, as illustrated by the carets ({@code ^}) below:
 * <PRE>
 *           Element(0)  Element(1)  Element(2)  ... Element(n-1)
 * cursor positions: ^      ^      ^      ^         ^
 * </PRE>
 * Note that the {@link #remove} and {@link #set(Object)} methods are
 * <i>not</i> defined in terms of the cursor position; they are defined to
 * operate on the last element returned by a call to {@link #next} or
 * {@link #previous()}.
 *
 * This interface is a member of the Java Collections Framework.*/
public interface ListIterator<E> extends Iterator<E> {
  // Query Operations

  /**
   * Returns {@code true} if this list iterator has more elements when
   * traversing the list in the forward direction. (In other words,
   * returns {@code true} if {@link #next} would return an element rather
   * than throwing an exception.)
   *
   * @return {@code true} if the list iterator has more elements when
   *     traversing the list in the forward direction
   */
  boolean hasNext();

  /**
   * Returns the next element in the list and advances the cursor position.
   * This method may be called repeatedly to iterate through the list,
   * or intermixed with calls to {@link #previous} to go back and forth.
   * (Note that alternating calls to {@code next} and {@code previous}
   * will return the same element repeatedly.)
   *
   * @return the next element in the list
   * @throws NoSuchElementException if the iteration has no next element
   */
  E next();

  /**
   * Returns {@code true} if this list iterator has more elements when
   * traversing the list in the reverse direction. (In other words,
   * returns {@code true} if {@link #previous} would return an element
   * rather than throwing an exception.)
   *
   * @return {@code true} if the list iterator has more elements when
   *     traversing the list in the reverse direction
   */
  boolean hasPrevious();

  /**
   * Returns the previous element in the list and moves the cursor
   * position backwards. This method may be called repeatedly to
   * iterate through the list backwards, or intermixed with calls to
   * {@link #next} to go back and forth. (Note that alternating calls
   * to {@code next} and {@code previous} will return the same
   * element repeatedly.)
   *
   * @return the previous element in the list
   * @throws NoSuchElementException if the iteration has no previous
   *     element
   */
  E previous();

  /**
   * Returns the index of the element that would be returned by a
   * subsequent call to {@link #next}. (Returns list size if the list
   * iterator is at the end of the list.)
   *
   * @return the index of the element that would be returned by a
   *     subsequent call to {@code next}, or list size if the list
   *     iterator is at the end of the list
   */
  int nextIndex();

  /**
   * Returns the index of the element that would be returned by a
   * subsequent call to {@link #previous}. (Returns -1 if the list
   * iterator is at the beginning of the list.)
   *
   * @return the index of the element that would be returned by a
   *     subsequent call to {@code previous}, or -1 if the list
   *     iterator is at the beginning of the list
   */
  int previousIndex();


  // Modification Operations

  /**
   * Removes from the list the last element that was returned by {@link
   * #next} or {@link #previous} (optional operation). This call can
   * only be made once per call to {@code next} or {@code previous}.
   * It can be made only if {@link #add} has not been
   * called after the last call to {@code next} or {@code previous}.
   *
   * @throws UnsupportedOperationException if the {@code remove}
   *     operation is not supported by this list iterator
   * @throws IllegalStateException if neither {@code next} nor
   *     {@code previous} have been called, or {@code remove} or
   *     {@code add} have been called after the last call to
   *     {@code next} or {@code previous}
   */
  void remove();

  /**
   * Replaces the last element returned by {@link #next} or
   * {@link #previous} with the specified element (optional operation).
   * This call can be made only if neither {@link #remove} nor {@link
   * #add} have been called after the last call to {@code next} or
   * {@code previous}.
   *
   * @param e the element with which to replace the last element returned by
   *     {@code next} or {@code previous}
   * @throws UnsupportedOperationException if the {@code set} operation
   *     is not supported by this list iterator
   * @throws ClassCastException if the class of the specified element
   *     prevents it from being added to this list
   * @throws IllegalArgumentException if some aspect of the specified
   *     element prevents it from being added to this list
   * @throws IllegalStateException if neither {@code next} nor
   *     {@code previous} have been called, or {@code remove} or
   *     {@code add} have been called after the last call to
   *     {@code next} or {@code previous}
   */
  void set(E e);

  /**
   * Inserts the specified element into the list (optional operation).
   * The element is inserted immediately before the element that
   * would be returned by {@link #next}, if any, and after the element
   * that would be returned by {@link #previous}, if any. (If the
   * list contains no elements, the new element becomes the sole element
   * on the list.) The new element is inserted before the implicit
   * cursor: a subsequent call to {@code next} would be unaffected, and a
   * subsequent call to {@code previous} would return the new element.
   * (This call increases by one the value that would be returned by a
   * call to {@code nextIndex} or {@code previousIndex}.)
   *
   * @param e the element to insert
   * @throws UnsupportedOperationException if the {@code add} method is
   *     not supported by this list iterator
   * @throws ClassCastException if the class of the specified element
   *     prevents it from being added to this list
   * @throws IllegalArgumentException if some aspect of this element
   *     prevents it from being added to this list
   */
  void add(E e);
}

ListIteratorの機能がより強く、定義された方法があります。
1）.has Next()は前へ繰り返し、もし次の要素があれば真に戻ります。
2）next()は次の要素の値を返し、ポインタを1とします。
3）ハスProvious（）は反対方向に遍歴し、もし要素があれば真に戻す；
4）previous()は前の要素の値を返し、ポインタを前に1つ移動します。
5）nextIndex()は、このときnext()メソッドを呼び出したときに戻ってくる要素の索引を返します。
6）previous Index()は、この時点でprevious()メソッドを呼び出した時に戻る要素のインデックスを返します。
7).remove()は、最近のnext()またはprevious()メソッドで返された要素を削除します。
8）set(E e)は、このときnext()またはprevious()を呼び出したら戻る要素を要素eで置換します。
9）add（E e）は、このときnext()が戻る要素を呼び出す前に、またはprevious()が戻ってくる要素を呼び出した後に、要素を追加します。
より詳細な説明はソースのコメントを読んでください。
3.IteratorとListIteratorの違い
  IteratorとListIteratorの方法は次の表を比較します。
Iterator
ListIterator
 
has Next()
has Next()
上書き
next()
next()
上書き
remove()
remove()
上書き
forEach Remaning（Consmer<？super E> action
forEach Remaning（Consmer<？super E> action
引き継ぐ
 
has Prvious()
 
 
previous()
 
 
next Index()
 
 
previous Index()
 
 
set(E e)
 
 
add(E e)
 
両者の違いは主に以下の通りである。
1）Iteratorは一方向にしか移動できません。ListIteratorは双方向に移動できます。
2）ListIteratorは要素を削除、置換または追加できますが、Iteratorは要素を削除するしかありません。
3）ListIteratorは、next()またはprevious()を呼び出して戻る要素のインデックスを返すことができますが、Iteratorはできません。
読んでくれてありがとうございます。みなさんのご協力をお願いします。ありがとうございます。