Iterators are a way to walk from element to element in a
data structure.  We developed them because sometimes
indexing is not appropriate for a particular data structure
like it was for array-like containers.  For instance, linked
lists.  Not so good at indexing since they have to do
pointer hopping to get from node to node and count along the
way.  So don't force an old approach on a new concept!

Iterators abstract away the underlying approach and allow
the programmer using them to just say "take me to the next
piece of data".  They are therefore implemented as classes.

Sometimes these are nested inside the container class and
sometimes they are separate.  A nested implementation will
have more details about the container's basic storage and be
able to do things more efficiently.  But non-nested
implementations can have their place, too.  Extensibility
and flexibility, for instance.

The most basic operations found on all iterators are:

   Operation    |   C++       |   Java
  --------------+-------------+------------------
   initialize   |  .begin()   |  .iterator()
   termination  |  .end()     |  .hasNext()
   access       |  operator*  |  .next()   \_____ does both at once
   advance      |  operator++ |  .next()   /

Depending on the type of iterator, other operations might
also be available.  (C++ actually supports many types of
iteration, so make sure you are using the right type for the
job!)