Iterator Pattern

[simorgh hossein]

Please explain Iterator Pattern in JAVA by a simple example,Thanks in advance
[ November 11, 2008: Message edited by: simorgh hossein ]

[Nitesh Kant]

Iterator pattern is extensively used by all java Collection classes.
Nothing like going through the code and understanding yourself

[Sergey Arnaut]

The java implementationof iterator pattern allows user to traverse carious types of data sets without worrying about the underlying implementation of collection. Since clients simply interact with the iterator for themselves. Some will allow full access to the underlying data sets while others may restrict certain functionalities, such as removing items.

---- "Design patterns" by Jason McDonald

For example, just open src.zip in your JAVA_HOME or whait a few ours till I found my old examples

[Sergey Arnaut]

Here is example:

/**
 * @(#)ArrayCollection.java        1.0 20/03/2008
 *
 * Copyright (c) Arnaut Sergey
 */
 
package labwork.task5;
 
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
 
/**
 * This class represents ArrayCollection class.
 * 
 * @author Arnaut Sergey
 */
public class ArrayCollection<E> implements interfaces.task5.ArrayCollection<E> {
 
/**
 * The array buffer into which the elements of the ArrayList
 * are stored. The capacity of the ArrayList is the length of
 * this array buffer.
 */
private transient E[] array;
 
/**
 * The size of the ArrayList (the number of elements it
 * contains).
 * 
 * @serial
 */
private int size;
/**
 * The array buffer into which the elements of the ArrayList
 * are stored. The capacity of the ArrayList is the length of
 * this array buffer.
 */
private transient int modCount = 0;
/**
 * Constructs an empty list with the specified initial
 * capacity.
 * 
 * @param initialCapacity
 *                the initial capacity of the list.
 */
 
public ArrayCollection(int initialCapacity) {
super();
if (initialCapacity < 0) {
throw new IllegalArgumentException("Illegal Capacity: "
+ initialCapacity);
}
this.array = (E[]) new Object[initialCapacity];
}
 
/**
 * Returns the array representation of ArrayCollection.
 * 
 * @return Object[] array
 */
public Object[] getArray() {
return this.array;
}
 
/**
 * Sets the array representation of ArrayCollection.
 * 
 * @param arg0
 *                Array that is must be set as ArrayCollection
 */
public void setArray(E[] arg0) {
if (arg0 == null) {
throw new NullPointerException();
}
this.array = arg0;
}
 
/**
 * Adds an element to the ArrayCollection.
 * 
 * @param o
 *                Element needed to be added
 * 
 * @return <code>true</code> (as per general Contract of
 *         Collection.add)
 */
public boolean add(Object o) {
ensureCapacity(size + 1);
array[size++] = (E) o;
return true;
}
 
/**
 * Retains only the elements in this collection that are
 * contained in the specified collection (optional operation).
 * In other words, removes from this collection all of its
 * elements that are not contained in the specified
 * collection.
 * 
 * @param c
 *                elements to be retained in this collection.
 * @return <tt>true</tt> if this collection changed as a
 *         result of the call.
 */
public boolean retainAll(Collection<?> c) {
if (c == null) {
throw new NullPointerException(
"Collection needed but 'null' recieved");
}
boolean modified = false;
Iterator<E> e = iterator();
while (e.hasNext()) {
if (!c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
 
/**
 * Appends all of the elements in the specified Collection to
 * the end of this list, in the order that they are returned
 * by the specified Collection's Iterator. The behavior of
 * this operation is undefined if the specified Collection is
 * modified while the operation is in progress. (This implies
 * that the behavior of this call is undefined if the
 * specified Collection is this list, and this list is
 * nonempty.)
 * 
 * @param c
 *                the elements to be inserted into this list.
 * @return <tt>true</tt> if this list changed as a result of
 *         the call.
 */
public boolean addAll(Collection<? extends E> c) {
if (c.getClass().isInstance(this)) {
throw new IllegalArgumentException();
}
ensureCapacity(size + c.toArray().length); // Increments
// modCount
System.arraycopy(c.toArray(), 0, array, size,
c.toArray().length);
size += c.toArray().length;
return c.toArray().length != 0;
}
 
/**
 * Returns <tt>true</tt> if this collection contains all of
 * the elements in the specified collection.
 * 
 * @param c
 *                collection to be checked for containment in
 *                this collection.
 * @return <tt>true</tt> if this collection contains all of
 *         the elements in the specified collection.
 */
public boolean containsAll(Collection<?> c) {
Iterator<?> e = c.iterator();
while (e.hasNext()) {
if (!contains(e.next())) {
return false;
}
}
return true;
}
 
/**
 * Increases the capacity of this <tt>ArrayList</tt>
 * instance, if necessary, to ensure that it can hold at least
 * the number of elements specified by the minimum capacity
 * argument.
 * 
 * @param minCapacity
 *                the desired minimum capacity.
 */
public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = array.length;
if (minCapacity > oldCapacity) {
Object[] oldData = array;
int newCapacity = oldCapacity + 1;
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
array = (E[]) new Object[newCapacity];
System.arraycopy(oldData, 0, array, 0, size);
}
}
 
/**
 * Decreases the capacity of this <tt>ArrayList</tt>
 * instance.
 * 
 */
public void encloseCapacity() {
modCount++;
Object[] oldData = array;
int newCapacity = array.length - 1;
this.size--;
if (size != 0) {
array = (E[]) new Object[newCapacity];
} else {
this.setArray((E[]) new Object[0]);
}
System.arraycopy(oldData, 0, array, 0, size);
}
 
/**
 * Removes all of the elements from the array.
 * 
 * @param No
 */
public void clear() {
this.array = (E[]) new Object[0];
size = 0;
}
 
/**
 * Checks contains element in the array.
 * 
 * @param elem
 *                An element is checked for a presence
 * 
 * @return <code>true</code> if element is contained in
 *         collection. <code>false</code> if element is not
 *         contained in collection
 */
public boolean contains(Object elem) {
return indexOf(elem) >= 0;
}
 
/**
 * Searches for the first occurence of the given argument,
 * testing for equality using the <tt>equals</tt> method.
 * 
 * @param elem
 *                an object.
 * @return the index of the first occurrence of the argument
 *         in this list; returns <tt>-1</tt> if the object
 *         is not found.
 */
public int indexOf(Object elem) {
if (elem == null) {
for (int i = 0; i < size; i++) {
if (array[i] == null) {
return i;
}
}
} else {
for (int i = 0; i < size; i++) {
if (elem.equals(array[i])) {
return i;
}
}
}
return -1;
}
 
/**
 * Checks collection for emptiness.
 * 
 * @param No
 * 
 * @return <code>true</code> if collection is empty.
 *         <code>false</code> if collection is not empty.
 */
public boolean isEmpty() {
return size == 0;
}
 
/**
 * Creates new iterator for this collection.
 * 
 * @param No
 * 
 * @return new Iterator
 */
public Iterator<E> iterator() {
return new ArrayIterator();
}
 
/**
 * Removes element from collection.
 * 
 * @param o
 *                Element needed to be removed
 * 
 * @return <code>true</code> if element is removed.
 *         <code>false</code> if element is not removed.
 */
public boolean remove(Object o) {
for (int index = 0; index < size; index++) {
if (o.equals(array[index])) {
fastRemove(index);
return true;
}
}
return false;
}
 
/**
 * Removes from this collection all of its elements that are
 * contained in the specified collection (optional operation).
 * 
 * @param c
 *                elements to be removed from this collection.
 * @return <tt>true</tt> if this collection changed as a
 *         result of the call.
 */
 
public boolean removeAll(Collection<?> c) {
if (c == null) {
throw new NullPointerException("Collection nee"
+ "ded but 'null' receaved");
}
boolean modified = false;
Iterator<?> e = iterator();
while (e.hasNext()) {
if (c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
 
/**
 * Private remove method that skips bounds checking and does
 * not return the value removed.
 */
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0) {
System.arraycopy(array, index + 1, array, index,
numMoved);
}
encloseCapacity();
}
 
/**
 * Returns the size of collection.
 * 
 * @param No
 * @return the size of collection
 */
public int size() {
return this.size;
}
 
/**
 * Returns an array representation of this collection.
 * 
 * @param No
 * @return array
 */
public Object[] toArray() {
return this.array;
}
 
/**
 * Returns an array containing all of the elements in this
 * list in the correct order; the runtime type of the returned
 * array is that of the specified array.
 * 
 * @param <T>
 *                Generic type
 * @param a
 *                the array into which the elements of the
 *                list are to be stored, if it is big enough;
 *                otherwise, a new array of the same runtime
 *                type is allocated for this purpose.
 * @return array
 */
public <T> T[] toArray(T[] a) {
if (a.length < size) {
a = (T[]) java.lang.reflect.Array.newInstance(a
.getClass().getComponentType(), size);
}
System.arraycopy(array, 0, a, 0, size);
if (a.length > size) {
a[size] = null;
}
return a;
}
 
/**
 * Returns an element of collection specified by index.
 * 
 * @param index
 *                Specifies an element in the collection.
 * @return element specified by index
 */
public E get(int index) {
rangeCheck(index);
return array[index];
}
 
/**
 * Check if the given index is in range. If not, throw an
 * appropriate runtime exception. This method does *not* check
 * if the index is negative: It is always used immediately
 * prior to an array access, which throws an
 * ArrayIndexOutOfBoundsException if index is negative.
 */
private void rangeCheck(int index) {
if (index >= size) {
throw new IndexOutOfBoundsException("Index: " + index
+ ", Size: " + size);
}
}
 
/**
 * Creates new ArrayCollection.
 */
public ArrayCollection() {
this(0);
}
 
private class ArrayIterator implements
interfaces.task5.ArrayIterator<E>, Iterator<E> {
 
/**
 * Index of element to be returned by subsequent call
 * to next.
 */
private int cursor = 0;
 
/**
 * Index of element returned by most recent call to
 * next or previous. Reset to -1 if this element is
 * deleted by a call to remove.
 */
private int lastRet = -1;
 
/**
 * The modCount value that the iterator believes that
 * the backing List should have. If this expectation
 * is violated, the iterator has detected concurrent
 * modification.
 */
private int expectedModCount = modCount;
 
public boolean hasNext() {
return cursor < size();
}
 
public E next() {
checkForComodification();
try {
E next = get(cursor);
lastRet = cursor++;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
 
public void remove() {
if (lastRet == -1) {
throw new IllegalStateException();
}
checkForComodification();
try {
ArrayCollection.this
.remove(ArrayCollection.this
.get(lastRet));
if (lastRet < cursor) {
cursor--;
}
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}

 
final void checkForComodification() {
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
 
public Object[] getArray() {
return ArrayCollection.this.toArray();
}
 
public ArrayIterator() {
 
}
}
}

Any questions?