This article mainly introduces the relevant information of java Iteratorinterface and LIstIterator interface analysis. Friends who need it can refer to it
java Iterator interface and LIstIterator interface analysis
Directory
1.Iterator interface
2.ListIterator
3.Iterator and The difference between ListIterator
Text
Before continuing to look at the ArrayList source code, first understand the Iterator interface and the ListIterator interface. The next article will explain ArrayList in detail How to implement them.
We know that the interface is just a specification. When inherits the interface and implements the methods in it, the interface's description of the methods must be followed.
1.Iterator interface
The Iterator interface replaces the Enumeratrion in the Java collection framework . Iterators differ from enumerations in two main ways:
Iterators allow the caller to remove elements from the collection during the iteration process;
The method name has been improved.
Iterator source code is as follows:
/**
* 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 action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}The Iterator interface defines four methods and the functions of each method. If a class implements this interface and implements these methods, This method needs to implement the defined functions and follow these rules:
1).hasNext() determines whether the container has the next element, and returns true if there is;
2).next() returns The next element in the container;
3).remove() removes the last element returned by the current iterator. This method can only be called once after each call to the next() method;
4). Java 8 adds the forEachRemaining method, which can execute the specified function on all remaining elements. operate.
For more detailed instructions, please read the Comments in the source code.
2.ListIterator
ListIterator provides add, set, previous, etc. based on Iterator. Operations on lists. But ListIterator, like Iterator, still operates on the original list.
ListIterator source code is as follows:
/**
* 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 ListIteratorThe function of ListIterator is more powerful, and the defined methods are:
1).hasNext() when traversing forward , returns true if there is a next element;
2).next() returns the value of the next element and adds 1 to the pointer;
3).hasPrevious() traverses in the opposite direction If there are still elements, return true;
4).previous() Returns the value of the previous element and moves the pointer forward by 1;
5).nextIndex() Returns this time The index of the element returned when the next() method is called;
6).previousIndex() returns the index of the element returned when the previous() method is called; 7).remove() Removes the element returned by the most recent call to next() or previous() method (optional); 8).set(E e) Use element e to set if it is called at this time The element returned by the next() or previous() method is replaced; 9).add(E e) Adds an element before the element returned by calling next() at this time, or returns by calling previous() at this time after the element. For more detailed instructions, please read the comments in the source code.3. The difference between Iterator and ListIterator
| Iterator | ListIterator | |
| hasNext() | hasNext()Override | |
| next() | next()Overwrite | |
| remove() | remove()Overwrite | |
| forEachRemaining(Consumer action) | forEachRemaining(Consumer action)Inheritance | |
| hasPrevious() | ||
| previous() | ||
| nextIndex() | ||
| ##previousIndex() | ||
| set(E e) | ||
| add(E e) |
1).Iterator can only be one-way Move, ListIterator can move in both directions;
2).ListIterator can
delete, replace or add elements, while Iterator can only delete elements; 3).ListIterator can return The index of the current element (returned by calling next() or previous()), but Iterator cannot.
The above is the detailed content of A detailed introduction to the Iterator interface and LIstIterator interface in Java. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
