• Computers vs. Calculators:
  • Computers can perform the same operation many times
• Programming Languages:
  • Harness this power using loops
• A Problem:
  • Traditional looping requires an understanding of the structure of the "aggregate"

javaexamples/iterator/ArrayExample.java (Fragment: 1)

       String    city;

       for (int i=0; i < cities.length; i++)
       {
          city = cities[i];
          System.out.println(city);
       }
        

javaexamples/iterator/ArrayListExample.java (Fragment: 1)

       String    city;

       for (int i=0; i < cities.size(); i++)
       {
          city = cities.get(i);
          System.out.println(city);
       }
        

javaexamples/iterator/LinkedListExample.java (Fragment: 1)

       Node<String>      current;
       String            city;

       current = first;
       while (current != null)
       {
          city = current.value;
          System.out.println(city);
          current = current.next;
       }
        

• Applications often "loop" over the same aggregate object in many classes and methods
• Changing from one aggregate to another is, as a result, very inconvenient
• The Iterator design pattern enables us to access the elements of an aggregate object while hiding its internal structure

• Reset its "pointer" (or cursor) to the first element.
• Determine if there are any more elements in the sequence.
• Move its "pointer" to the next element.
• Retrieve the "current" element.

• The Aggregates:
  • Classes that realize the Iterable interface (including classes that implement the List interface like ArrayList and classes that realize the Set interface like HashSet )
• The Iterator:
  • Classes that realize the Iterator interface

Note that the Map interface does not extend Iterable or Collection, but one can get a Set or Collection object from a Map.

    Iterable<String>    cities;

    cities = new ArrayList<String>();

    // Important code

    // An example loop
    Iterator<String>    i = cities.iterator();
    while (i.hasNext())
    {
       String city = i.next();
       System.out.println(city);
    }
    

• The Principle Benefit:
  • You can easily change the type of aggregate being used without having to change any loops (and, if you declare variables properly, without having to change any of the declarations, only the instantiations)
• Other Benefits:
  • Several objects can be "looping" over the elements in the aggregate at the same time
  • A "filtered" list (e.g., names starting with the letter "A") is handled in exactly the same way that the "unfiltered" version is

• The Idea:
  • Include a control structure that takes advantage of the Iterator Pattern (i.e., create a "for each" loop for any Object that implements the Iterable interface)
• Syntax:
  • for (Class element : Iterable) statement
• Example:

  •     Iterable<String>    cities;
    
        cities = new ArrayList<String>();
    
        // Important code
    
        // An example loop
        for (String city: cities)
        {
           System.out.println(city);
        }