Iterator Pattern in Java

Iterator Pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
It also places the task of traversal on the iterator object, not on the aggregate, which simplifies the aggregate interface and implementation and places the responsibility where it should be.
One Real time example of Iterator Pattern is the usage of Remote Controls in Home. This example I came accross when I was reading my husband's blog and found very intresting. I will share the same example with you.
Any Remote Control we use to start pressing up and down and back keys to iterate through the channels.

public interface Iterator {
 public Channel nextChannel(int currentChannel);
 public Channel previousChannel(int currentChannel);
}

The Channel iterator is common for all the remote controls.It's like a specification implemented by all the remote control manufacturing companies.

public class ChannelSurfer implements Iterator{
 public Channel nextChannel(int currentChannel) { 
  Channel channel=new Channel(currentChannel+1); 
  return channel; 
 }
 public Channel previousChannel(int currentChannel) { 
  Channel channel=new Channel(currentChannel-1);
  return channel; 
 }
}


public class RemoteControl {
 private ChannelSurfer surfer;
 public RemoteControl() { 
  surfer=new ChannelSurfer(); 
 }
 public Program getProgram(ChannelSurfer surfer) {
  return new Program(surfer.nextChannel());
 }
}

public class Program {// ... Some specific implementation of Program class.}
}

We all know that every channel is associated with program and it's basically the program and not the channel number which a user wants to see.This applies that we can apply some logic before returning the elements through iterator.Iterator here can also be programmed to return 'the programs' straight away rather than returning the channels.
Common Java Iterator is Iterator itself.Interface Signature has been copied from the javadoc.
An iterator over a collection. Iterator takes the place of 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.

public interface Iterator<E> {
 boolean hasNext();
 E next();
 void remove();
}

java.util.Collection interface a root interface in Collections hierarchy contains a method iterator() which returns the Iterator interface.
Hence any class implementing Collection interface should provide definition for iterator() method.But please note that there are no Guarantees concerning the order(unless this collection is an instance of some class that provides a guarantee) as List by definition guarantees ordered Collection.
When we try to view List interface which extends Collection interface it has a method iterator() which returns an Iterator over the elements in this list in proper sequence.
Now coming to ArrayList a subclass class implementing List interface - which also extends AbstractList class provides definition for iterator() method.Infact all the underlying logic sits in AbstractList class.
When we try to view code it tries to return a Itr innerClass object.

public Iterator<E> iterator() {
 return new Itr();    
}   
public E remove(int index) {
 throw new UnsupportedOperationException();    
}

 

Other Patterns

Composite Pattern
Iterators are often used to recursively traverse composite structures.
Factory Method
Polymorphic iterators use factory methods to instantiate the appropriate iterator subclass.