Applied Design Patterns with Java

Behavioral :: Iterator (257) {C ch 19}

Example - Java :: Patterns\Behavioral\Iterator

Pattern Concept: to allow moving through a list or collection of objects using a standard interface, and without knowing the internal representation details of these objects. The Iterator pattern is useful because it provides a way to move through a set of elements without exposing the design of the element's classes. An Iterator is thus a logical navigation object.

An interface Iterator structure is used to operate on elements of type Object. Remember that all objects in Java ultimately derive from Object. Java 2 has such an interface Iterator already defined:

public interface Enumeration {

public boolean hasMoreElements();

public Object nextElement();

}

Here is a subset of the interface tree listing from the Java 2 help system:

This Enumeration type is used in Java 2 Vector and Hashtable classes; both contain a method that returns an enumeration:

public Enumeration elements();

Any instance of Vector, Hashtable, or any classes that derive from them, has this method available. The use of the Enumeration interface is the preferred way to build a Java Iterator. Java 2 also has an interface Iterator, which has the added feature of allowing the user to remove an element from a list.

Example - UML : KidEnumeration
Here is Cooper's Class Diagram for the application using this logic, followed by the Rose equivalent:

The example Java program is called 'KidEnumeration'.

The UML diagram is above, and the list of Java files is below:

Issues and consequences of the Iterator pattern include:

• Data Modification: should an Iterator be allowed to alter a list or its contents? Many language purists insist that an Iterator should only be a read-only navigator, never altering in any way the list it navigates. The Java 2 Enumeration interface meets this criteria, but the Iterator interface does not. In a multi-threaded environment, this can be difficult and complex: one thread might alter a list while another thread is navigating through the list. Synchronizing element operations can be a problem that needs great care to resolve.
• Privileged Access: an Iterator might need some sort of privileged access to the underlying list's objects. Managing the objects with Vector or Hashtable objects readily solves this problem. Another solution is to make the Iterator a derived class of the containing class; this child instance would have the data and the Iterator in the same object. Java has no equivalent to the C++ friend.
• External versus Internal Iterator: The Cooper example shows an external Iterator. An Internal Iterator moves through a container performing operations on the entire collection directly, without any external requests or controls. An External Iterator is the more general approach, since it allows an external requestor the choice of selecting and operating only on specific elements.

Catalog Behavioral Prev Next