java中關於Iterator介面和LIstIterator介面的具體介紹

這篇文章主要介紹了java  Iterator介面和LIstIterator介面分析的相關資料,需要的朋友可以參考下

#java  Iterator介面和LIstIterator介面分析

#目錄

1.Iterator介面
2.ListIterator
3.Iterator和ListIterator的區別 

正文

在繼續看ArrayList源碼之前，先了解Iterator接口和ListIterator接口，下篇文章詳細講解ArrayList是如何實現它們的。

我們知道，介面只是一種規範，當繼承介面並實作其中的方法時，要遵循介面對方法的說明。

1.Iterator介面

Iterator介面取代了Java集合框架中的Enumeratrion。 Iterators不同於enumerations的地方主要有兩點：

　　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 class="brush:php;toolbar:false">{@code
   *   while (hasNext())
   *     action.accept(next());
   * }

   *    * @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介面定義了四個方法以及各個方法的功能，如果有類別實作了這個接口，且實作了這些方法，這個方法需要實作定義的功能，遵循這些規則：

　　1).hasNext() 判斷容器是否有下一個元素，有則傳回true;

　　2).next() 返回容器中的下一個元素;

　　3).remove() 移除目前迭代器傳回的最後一個元素。這個方法在每次呼叫next()方法之後只能呼叫一次；

　　4).Java 8 增加forEachRemaining方法，它可以實作對餘下的所有元素執行指定的操作。

更詳細的說明請閱讀原始碼中的註解。

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: ^      ^      ^      ^         ^
 * 

 * Note that the {@link #remove} and {@link #set(Object)} methods are  * not 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 extends Iterator {   // 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).hasNext() 向前遍歷時，如果有下一個元素傳回真；

　　2).next() 傳回下一個元素的值，並將指標加1;

　　3).hasPrevious() 往相反方向遍歷時，如果還有元素傳回真；

　　4).previous() 傳回上一個元素的值，並將指標前移1;

　　5).nextIndex() 傳回此時呼叫next()方法時傳回的元素的索引;

　　6).previousIndex() 傳回此時呼叫previous()方法時傳回的元素的索引；

　　7).remove() 移除最近一次調用next()或previous()方法返回的元素（可選）；

　　8).set(E e) 用元素e將如果此時調用next()或previous()方法傳回的元素被替換掉；

　　9).add(E e) 新增元素到此時呼叫next()傳回的元素之前，或此時呼叫previous()返回的元素之後。

更詳細的說明請閱讀原始碼中的註解。

3.Iterator與ListIterator的差異

#  Iterator與ListIterator的方法比較如下表：

##  nextIndex()  previousIndex()  set(E e)  add(E e)  

#Iterator	ListIterator	#
hasNext()	hasNext()	覆寫
#next()	next()	覆寫
remove()	#remove()	已覆寫
forEachRemaining(Consumer super E> action)	forEachRemaining(Consumer super E> action)	繼承
	hasPrevious()
#	previous()

二者的差異主要有：

　　1).Iterator只能單向移動，ListIterator可以雙向移動；

　　2).ListIterator可以

刪除、替換或添加元素，而Iterator只能刪除元素；

#　　3).ListIterator可以返回目前（呼叫next()或previous()傳回的）元素的索引，而Iterator不能。

以上是java中關於Iterator介面和LIstIterator介面的具體介紹的詳細內容。更多資訊請關注PHP中文網其他相關文章！