Iterador

O padrão de projeto Iterator é um padrão comportamental, é utilizado para acessar o conteúdo de um agregado (coleções, arrays, listas vinculadas e tabelas de hash) sem expor a sua representação interna. Oferece uma interface uniforme para atravessar diferentes estruturas agregadas.

Segundo Eric & Elisabeth Freeman, este padrão permite que você acesse um a um os elementos de uma agregado mesmos sem saber como eles estão sendo representados. O efeito do interator em um projeto é de grande importância, se você tiver uma maneira uniforme de acessar os elementos de todas os seus agregados, permitira escrever código polimórfico que funcione em qualquer desses agregados.

Aplicação

Segundo Luis Francisco Thomazini Neto, esse padrão pretende oferecer uma interface consistente para que os elementos de uma estrutura de dados possam ser adequadamente percorridos, ou seja, ele pode ser usado para prover o acesso ao conteúdo dessas estruturas sem violar seu encapsulamento e sem a necessidade de conhecimento da representação interna. Permite ainda que diferentes formas de navegação sejam implementadas e possibilita o controle de múltiplos percursos da navegação por uma mesma estrutura.

O padrão iterator permite tomar de acessar e percorrer os elementos da coleção e atribuí-la à um objeto iterator. Permite que objetos acessem objetos individuais em qualquer estrutura de dados sem a necessidade de se conhecer o comportamento da estrutura de dados, como percorrer a estrutura ou remover um elemento dessa estrutura ou como essa estrutura de dados armazena objetos.

Segundo Paulo Tiago Gomes Casanova, o padrão de projeto iterator tem como finalidade prover uma maneira de percorrer sequencialmente os elementos de uma coleção sem violar o seu encapsulamento.

Permitir uma iteração por todos os elementos de um agregado, independente da estrutura de armazenamento. A classe Iterator possui uma interface para acessar os elementos da coleção. O objeto iterator reconhece o elemento atual, assim como os anteriores.

Como aplicação do interator permite acessar conteúdo de um objeto agregado sem expor sua representação interna.

Deseja-se suportar múltiplas travessias de um objeto agregado.

Quer-se prover uma interface uniforme para atravessar diferentes estruturas agregadas. Suportar iteração polimórfica.

Segundo Guilherme Lucio Abelha Mota e Antônio de Pádua Albuquerque Oliveira, O padrão iterator (iterador) permite a navegação em uma coleção de diferentes maneiras através de funções (métodos), retirando do objeto lista a responsabilidade de acesso e percurso, transferindo-a para um objeto iterator. Esse objeto proverá o acesso à lista sem expor seu conteúdo, preservando o encapsulamento. A classe Iterator define uma interface uniforme para acesso aos diferentes elementos da coleção, ou seja, que suporte iteração polimórfica. Um iterator é responsável por manter a posição do elemento corrente, sabendo quantos elementos já foram percorridos.

Classe Participantes

Iterador: Define uma interface que se possa acessar e caminhar nos elementos. Fornece um conjunto de métodos para acessar os elementos de uma coleção.

IteradorConcreto: Implementação da interface Iterator. Mantém estado para saber o elemento corrente na coleção. Responsável pelo gerenciamento da posição atual da iteração.

Agregado: Define uma interface para os objetos iterador. A definição da interface comum para os clientes permite, separar a implementação da sua coleção de objetos.

AgregadoConcreta: Implementação das interfaces de criação do iterador e o AgregadoConcreto possui uma coleção de objetos e implementa o método na qual retorna um Iterador para o coleção. Todos AgregadoConcreto é responsavel pela criação de uma instância de InteradorConcreto que possa fazer a iteração através da sua própria coleção de objetos.

Segundo Cássio Frederico Moreira Druziani, et al. Um objeto Iterator permite transferir a responsabilidade de acesso e percurso do objeto lista chamando-a para si. Ao percorrer uma lista, pode-se deixar a cargo de um objeto Iterator o controle de quais elementos já foram percorridos, isto é, identificar em que ponto da lista encontra-se o acesso.

Exemplo Prático de Implementação

Interface Iterator

package com.br.patterns.iterator;


abstract public class AbstractIterator {


	  // Methods
	  abstract public Item First();
	  abstract public Item Next();
	  abstract public boolean IsDone();
	  abstract public Item CurrentItem();
	

}

Implementação da interface Iterator (IteratorConcreto)

package com.br.patterns.iterator;



public class Iterator extends AbstractIterator {
	  // Fields
	  private Collection collection;
	  private int current = 0;
	  private int step = 1;

	  // Constructor
	  public Iterator( Collection collection )
	  {
	    this.collection = collection;
	  }

	  // Properties
	  public int getStep()
	  {
	    return step;
	  }
	  
	  public void setStep(int valor){
	  	this.step = valor;
	  }

	  // Methods
	  public Item First()
	  {
	    current = 0;
	    return (Item) collection.getItem(0);
	  }

	  public Item Next()
	  {
	    current += step;
	    if( !IsDone() )
	      return (Item) collection.getItem(current);
	    else
	      return null;
	  }

	  public Item CurrentItem()
	  {
	    return (Item)collection.getItem(current);
	  }

	  public boolean IsDone()
	  {
	    return current >= collection.getCount() ? true : false ;
	  }

}

Interface Agregado

package com.br.patterns.iterator;


public abstract class AbstractCollection {
	abstract public Iterator CreateIterator();
}

Implementação da Inteface Agregado(ConcreteAgregado)

package com.br.patterns.iterator;

import java.util.ArrayList;



public class Collection extends AbstractCollection{
	private ArrayList items = new ArrayList();

	  // Methods
	  public Iterator CreateIterator()
	  {
	    return new Iterator( this );
	  }

	  // Properties
	  public int getCount()
	  {
	    return items.size();
	  }

	  // Indexers
	  
	  public void adicionar(Object value){
	  	items.add(value);
	  }

	  public Object getItem(int i){
	  	return items.get(i);
	  }
}

Classe Cliente

package com.br.patterns.iterator;


public class Cliente {
	  public static void main(String[] args)
	  {
	    // Build a collection
	    Collection collection = new Collection();
	    collection.adicionar(new Item( "Item 0" ));
	    collection.adicionar(new Item( "Item 1" ));
	    collection.adicionar(new Item( "Item 2" ));
	    collection.adicionar(new Item( "Item 3" ));
	    collection.adicionar(new Item( "Item 4" ));
	    collection.adicionar(new Item( "Item 5" ));
	    collection.adicionar(new Item( "Item 6" ));
	    collection.adicionar(new Item( "Item 7" ));
	    collection.adicionar(new Item( "Item 8" ));

	    // Create iterator
	    Iterator iterator = new Iterator( collection );
	   
	    // Skip every other item
	    iterator.setStep(1);

	    // For loop using iterator
	    for( Item item = iterator.First();
	          !iterator.IsDone(); item = iterator.Next() )
	    {
	      System.out.println(item.getName() );
	    }
	  }
}