subclasse de Iterator.

template class ListIterator : public Iterator {

        public:ListIterator(const List* aList);
        virtual void First();
        virtual void Next();
}

Imprime o nome de todos os membros com um loop for-each:

for (Person p : roster) {
        System.out.println(p.getName());
}

Imprime o nome de todos os com o forEach operação de agregação:

roster.stream().forEach(e->System.out.println(e.getName());

Encapsula uma iteração

template class FilteringListTraverser {
         public: FilteringListTraverser(List* aList);
         bool Traverse();
         protected:
         virtual bool ProcessItem(const Item&) = 0;

}

Toda a lógica iteração pode ser reutilizado.

ListIterator i(employees);
int count = 0;
for (i.First(); !i.IsDone(); i.Next()) {
         count++;
         i.CurrentItem()->Print();
        if (count >= 10) {
            break;
       }
}

Imprimir todos os  dados independente de uma representação concreta

AbstractList*>* employees;
   // ...
Iterator*>* iterator = employees->CreateIterator();
PrintEmployees(*iterator);
delete iterator;

Retornar um objeto ListIterator

template Iterator*>* List::CreateIterator () const {
               return new ListIterator(this);
}

Avançar o elemento atual

template void ListIterator::Next () {
        _current++;
}

Posiciona o iterador para o primeiro elemento

template void ListIterator::First () {
     _current = 0;
}

Habilitar iteração polimórfica, AbstractList

template class AbstractList {
      public: virtual Iterator* CreateIterator() const = 0;
     // ...
}

Criar um vetor e adicionar alguns itens

public static void main(String args[]) {
         Vector v = new Vector();
        v.addElement(new Integer(5));
        v.addElement(new Integer(9));
        v.addElement(new String("Hi, There!"));

}

Exemplo onde iterador externo é usado

for (Iterator it = options.iterator(); it.hasNext(); {
      String name = (String)it.next();
      System.out.println(name);
}
    Iterator name = options.iterator();
while (name.hasNext() ){
        System.out.println(name.next() );
}
for (Object item : options)
      System.out.println(((String)item));

Evitando compromisso com a implementação da lista específica.

SkipList* employees;
  // ...
SkipListIterator iterator(employees);
   PrintEmployees(iterator);
    template class AbstractList {
        public virtual Iterator* CreateIterator() const = 0;
       // ...
     }
  template Iterator* List::CreateIterator () const {
      return new ListIterator(this);
 } 

Calcular a média de idade de todos os membros armazenados em uma estrutura de dados

double average = roster.stream().filter(p >p.getGender()==Person.Sex.MALE).mapToInt(Person::getAge) .average() .getAsDouble();

Interface Iterator

public interface Iterator {
     boolean hasNext();
     E next();
     void remove(); //optional
}

Remoção de elementos específicos.

static void filter(Collection c) {
     for (Iterator it = c.iterator(); it.hasNext(); )
       if (!cond(it.next()))
           it.remove();
}

Encapsular diferentes tipos de iteração

template class FilteringListTraverser {
        public: FilteringListTraverser(List* aList);
        bool Traverse();
        protected: virtual bool ProcessItem(const Item&) = 0;
        virtual bool TestItem(const Item&) = 0;
private: ListIterator _iterator;
}
template void FilteringListTraverser::Traverse () {
      bool result = false;
     for ( _iterator.First();
     !_iterator.IsDone();
     _iterator.Next() ) {
           if (TestItem(_iterator.CurrentItem())) {
              result = ProcessItem(_iterator.CurrentItem());
                 if (result == false) {
                       break;
                  }
          }
  }
  return result;

}

Lista e Iterator interfaces.

template class List {
         public: List(long size = DEFAULT_LIST_CAPACITY);
         long Count() const;
         Item& Get(long index) const;
         // ...
}
template class Iterator {
         public: virtual void First() = 0;
         virtual void Next() = 0;
        virtual bool IsDone() const = 0;
        virtual Item CurrentItem() const = 0;
        protected: Iterator();
}

Usando iterators para tornar a impressão mais fácil

Void PrintEmployees (Iterator& i){

         for(i.First(); !i.IsDone(); i.Next()){  

                i.CurrentItem()->Print();
          }
}

Certificando-se iterators são apagados

template class IteratorPtr {
            public: IteratorPtr(Iterator* i): _i(i) { }
           ~IteratorPtr() {delete _i; }
           Iterator* operator->() { return _i; }
           Iterator& operator*() { return *_i; }
           private: IteratorPtr(const IteratorPtr&);
          IteratorPtr& operator=(const IteratorPtr&);
          private: Iterator* _i;
}
AbstractList* employees;
// ...

IteratorPtr iterator(employees->CreateIterator());
PrintEmployees(*iterator);