Collection Classes: Basics
Including Iterators

Thus, studying collection classes now brings all these features back into focus, each sharing the spotlight with -and complementing- the others. Once you accept the power of these tools, and practice using them, you'll never think about plain old arrays in the same way again (and maybe you'll never think of them at all).

This lecture begins with a taxonomy of the collection classes, and an introduction to the interfaces, abstract classes, and concrete classes that are used to define them. The second part of this lecture explores iterators, which is an interesting concept by itself, but which takes on a central role when coupled with collection classes. We can create extremely sophisticated and efficient behavior by composing collection classes (for modelling complex data) and processing them with iterators.

The following legend explains the three levels and some of the notation used.

  public interface Iterator {
    public boolean hasNext();
    public Object  next   ();
      throws NoSuchElementException
    public void    remove ();
      throws UnsupportedOperationException, IllegalStateException
  }

  for (Iterator i = an-iterator-object; i.hasNext(); ) {
    Object o = i.next();
    ...process o...
  }

Because next can throw an exception, we can also write the following loop to iterate over a sequence of values, which is equivalent to the first

  for (Iterator i = an-iterator-object; ; ) 
    try {
      Object o = i.next();
      ...process o...
    } catch (NoSuchElementException nsee){break;}
  }

The Squares class illustrates how to write a simple class that implements this interface; it contains only a constructor and the methods required to implement the Iterator interface.

  public class Squares implements Iterator {

    private int current;
    private int leftToGenerate;

    public Squares(int numberToGenerate)
    {this(0,numberToGenerate-1);}

    public Squares(int start, int stop)
    {
      current        = start;
      leftToGenerate = stop-start+1;
    }

    public boolean hasNext()
    {return leftToGenerate != 0;}

    public Object next ()
      throws NoSuchElementException
    {
      if (!hasNext())
        throw NoSuchElementException("Squares: next");
      leftToGenerate--;
      Integer answer = new Integer(current*current);
      current++;
      return answer;
    }

    public void remove ()
      throws UnsupportedOperationException, IllegalStateException
    {throw UnsupportedOperationException("Squares: remove");}
  }

  for (Iterator i = new Squares(10); i.hasNext(); )
    System.out.println(i.next());

To illustrate iterators, we will add a method to this class with the prototype public Iterator iterator(): it returns a reference to an object from some class that implements Iterator (over the sequence of values that this collection stores). It is simple to use the result returned by this class with the idiom shown above; to print all the values in the queue (without changing their order in the queue) we would write just

  SimpleQueue sq = new SimpleQueue();
  ...put some values in the queue...
  for (Iterator i = sq.iterator(); i.hasNext(); )
    System.out.println(i.next());

In this context, it is useful to discuss the concept of an inner class. Sometimes -as with iterators- it is useful to declare a private class INSIDE another (public) class. By doing so, Java allows some interesting behaviors to emerge.

1. Only the methods in the outer class can construct objects from the inner class; in fact, only non-static methods can do so (or the Java compiler will detect and report an error).

2. When a method in the outer class constructs an object from its inner class, the inner class object can refer to all the instance variables by name (even private ones) in the outer class object that it was constructed in.

So, how can we extend the SimpleQueue to allow iterators? First, we must define the iterator method in that class as

  public Iterator iterator()
  {return new SimpleQueueIterator();}

  import java.util.Iterator;
  import java.util.NoSuchElementException;

  private class SimpleQueueIterator implements Iterator {
     private int next = 0;
     
    public boolean hasNext()
    {return next <= rear;}

    public Object next ()
      throws NoSuchElementException
    {
      if (!hasNext())
        throw new NoSuchElementException
          ("SimpleQueueIterator: next");

      return q[next++];
    }
    
    public void remove ()
      throws UnsupportedOperationException, IllegalStateException
    {throw new UnsupportedOperationException
       ("SimpleQueueIterator: remove");
    }
  }

If you get stumped on any problem, go back and read the relevant part of the lecture. If you still have questions, please get help from the Instructor, a TA, or any other student.

1. Write a class named Constant that implements Iterator. Its constructor should be called with some object, and its next method should always return a reference to that same object, with hasNext always returning true.

2. Write a class named Prime that implements Iterator, retuning only prime numbers. You may assume that the method public static boolean isPrime(int i) is defined in the Math class (it isn't, but assume it). Write a few reasonable constructors for this class.

3. Write a class named Combine that implements Iterator. Its constructor should be called with two objects constructed from a class implementing Iterator, and an object constructed from a class implementing Combine2.

     public interface Combine2 {
       public Object combine2(Object o1, Object o2);
     }

   The hasNext method returns true when both of the iterators it stores have a next value; its next method combines the next values from each of the iterators it stores.

4. What are the implications of defining the iterator method in SimpleQueue to be static.

5. Write an inner class implementing iterators of SimpleStack.

6. Devise a scheme whereby each mutator method in the SimpleQueue class detects if there is an iterator iterating over the object it is about to change, and throws the ConcurrentModificationException. Compare the efficiency of these two approaches to reportng this problem.