13518219792
这篇文章将为大家详细讲解有关Iterator与LIstIterator接口在java中的区别有哪些，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。
让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：域名注册、网页空间、营销软件、网站建设、美兰网站维护、网站推广。
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 the type of elements returned by this iterator*/
public interface Iterator {
/**
* 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
* The default implementation behaves as if:
*
{@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 cursor position 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:
*
* 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的方法对比如下表：
Iterator | ListIterator | |
hasNext() | hasNext() | 覆盖 |
next() | next() | 覆盖 |
remove() | remove() | 覆盖 |
forEachRemaining(Consumer<? super E> action) | forEachRemaining(Consumer<? super E> action) | 继承 |
| hasPrevious() | ||
| previous() | ||
| nextIndex() | ||
| previousIndex() | ||
| set(E e) | ||
| add(E e) |
二者的不同之处主要有：
1).Iterator只能单向移动，ListIterator可以双向移动；
2).ListIterator可以删除、替换或添加元素，而Iterator只能删除元素；
3).ListIterator可以返回当前（调用next()或previous()返回的）元素的索引，而Iterator不能。
关于Iterator与LIstIterator接口在java中的区别有哪些就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。
