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>{@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接口定义了四个方法以及各个方法的功能，如果有类实现了这个接口，且实现了这些方法，这方法需要实现定义的功能，遵循这些规则：

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: ^      ^      ^      ^         ^
* </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).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的方法对比如下表：

二者的不同之处主要有：

1).Iterator只能单向移动，ListIterator可以双向移动；

2).ListIterator可以删除、替换或添加元素，而Iterator只能删除元素；

3).ListIterator可以返回当前（调用next()或previous()返回的）元素的索引，而Iterator不能。

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

来源：http://www.cnblogs.com/songwenlong/p/6910799.html