org.apache.commons.collections.iterators

This package contains implementations of the {@link java.util.Iterator Iterator} interface.

You may also consider using {@link org.apache.commons.collections.IteratorUtils IteratorUtils}, which is a single class that uses static methods to construct instances of the classes in this package.

The array can be either an array of object or of primitives.

This class makes multiple iterators look like one to the caller When any method from the Iterator interface is called, the IteratorChain will delegate to a single underlying Iterator.

The ListIterator interface has additional useful methods for navigation - previous() and the index methods. This class allows a regular Iterator to behave as a ListIterator.

The iterator will loop continuously around the provided elements, unless there are no elements in the collection to begin with, or all the elements have been LoopingIterator.remove removed .

Concurrent modifications are not directly supported, and for most collection implementations will throw a ConcurrentModificationException.

This iterator does not support ObjectArrayIterator.remove , as the object array cannot be structurally modified.

The iterator implements a ObjectArrayIterator.reset method, allowing the reset of the iterator back to the start if required.
since:
   Commons Collections 3.0
version:
   $Revision: 155406 $ $Date: 2005-02-26 12:55:26 +0000 (Sat, 26 Feb 2005) $
author:
   James Strachan
author:
   Mauricio S.

This iterator does not support ObjectArrayListIterator.add or ObjectArrayListIterator.remove , as the object array cannot be structurally modified.

This iterator can extract multiple objects from a complex tree-like object graph. The iteration starts from a single root object. It uses a Transformer to extract the iterators and elements. Its main benefit is that no intermediate List is created.

For example, consider an object graph:

 |- Branch -- Leaf
 |         \- Leaf
 |- Tree |         /- Leaf
 |       |- Branch -- Leaf
 Forest |                 \- Leaf
 |       |- Branch -- Leaf
 |       |         \- Leaf
 |- Tree |         /- Leaf
 |- Branch -- Leaf
 |- Branch -- Leaf

 public Object transform(Object input) {
 if (input instanceof Forest) {
 return ((Forest) input).treeIterator();
 }
 if (input instanceof Tree) {
 return ((Tree) input).branchIterator();
 }
 if (input instanceof Branch) {
 return ((Branch) input).leafIterator();
 }
 if (input instanceof Leaf) {
 return input;
 }
 throw new ClassCastException();
 }

Internally, iteration starts from the root object.