java.util
public interface: ListIterator [javadoc |
source]
All Implemented Interfaces:
Iterator
All Known Implementing Classes:
ListItr, ListItr, ListItr, COWSubListIterator, COWIterator, ListItr, EmptyListIterator
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
#remove and
#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
#next or
#previous() .
This interface is a member of the
Java Collections Framework.
| Method from java.util.ListIterator Detail: |
|---|
 public void add(E e)
Inserts the specified element into the list (optional operation).
The element is inserted immediately before the element that
would be returned by #next , if any, and after the element
that would be returned by #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}.) |
public boolean hasNext() 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 #next would return an element rather
than throwing an exception.) |
public boolean hasPrevious() 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 #previous would return an element
rather than throwing an exception.) |
public E next() 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 #previous to go back and forth.
(Note that alternating calls to {@code next} and {@code previous}
will return the same element repeatedly.) |
public int nextIndex() Returns the index of the element that would be returned by a
subsequent call to #next . (Returns list size if the list
iterator is at the end of the list.) |
public E previous() 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
#next to go back and forth. (Note that alternating calls
to {@code next} and {@code previous} will return the same
element repeatedly.) |
public int previousIndex() Returns the index of the element that would be returned by a
subsequent call to #previous . (Returns -1 if the list
iterator is at the beginning of the list.) |
public void remove() Removes from the list the last element that was returned by #next or #previous (optional operation). This call can
only be made once per call to {@code next} or {@code previous}.
It can be made only if #add has not been
called after the last call to {@code next} or {@code previous}. |
public void set(E e) Replaces the last element returned by #next or
#previous with the specified element (optional operation).
This call can be made only if neither #remove nor #add have been called after the last call to {@code next} or
{@code previous}. |