DESIGN PATTERN #8: ITERATOR

• OBJETIVO

  • PROVER UMA FORMA DE SEQUENCIALMENTE ACESSAR OS ELEMENTOS DE UM OBJETO AGRAGADO SEM EXPOR SUA REPRESENTAÇÃO INTERNA

• TAMBÉM CONHECIDO COMO "CURSOR"

• MOTIVAÇÃO

  • QUEREMOS ISOLAR O USO DE UMA ESTRUTURA DE DADOS DE SUA REPRESENTAÇÃO INTERNA DE FORMA A PODER MUDAR A ESTRUTURA SEM AFETAR QUEM A USA

  • PARA DETERMINADAS ESTRUTURAS, PODE HAVER FORMAS DIFERENTES DE CAMINHAMENTO ("TRAVERSAL") E QUEREMOS ENCAPSULAR A FORMA EXATA DE CAMINHAMENTO

    • EXEMPLO: ÁRVORE PODE SER VARRIDA "EM ORDEM", "EM PÓS-ORDEM", EM "PRÉ-OREDEM"

    • EXEMPLO: PODEMOS TER UM "ITERADOR COM FILTRO" QUE SÓ RETORNA CERTOS ELEMENTOS DO AGREGADO

      • EXEMPLO: NO EDITOR DE DOCUMENTOS, PODERÍAMOS TER UM ITERADOR PARA ELEMENTOS NÃO GRÁFICOS (QUE PODEM TER SUA GRAFIA VERIFICADA, ...)

  • A IDÉIA DO ITERADOR É DE RETIRAR DO OBJETOS AGREGADO A RESPONSABILIDADE DE ACESSAR E CAMINHAR NA ESTRUTURA E COLOCAR A RESPONSABILIDADE NUM NOVO OBJETO SEPARADO CHAMADO UM ITERADOR

  • A CLASSE ITERADOR:

    • DEFINE UMA INTERFACE PARA ACESSAR OS ELEMENTOS DO OBJETO AGREGADO

    • MANTÉM QUALQUER INFORMAÇÃO DE ESTADO NECESSÁRIA PARA SABER ATÉ ONDE A ITERAÇÃO (CAMINHAMENTO) JÁ FOI

  • COMO CRIAR UM ITERADOR?

    • NÃO PODEMOS USAR NEW DE UMA CLASSE CONCRETA DIRETAMENTE POIS O ITERADOR A SER CRIADO DEPENDE DO OBJETO AGREGADO A SER VARRIDO

    • SOLUÇÃO: O OBJETO AGREGADO TEM UM FACTORY METHOD PARA CRIAR UM ITERADOR

      • EXEMPLO EM JAVA: Vector.elements()

• APLICABILIDADE: USE O PADRÃO ITERADOR

  • PARA ACESSAR O CONTEÚDO DE UM OBJETO AGREGADO SEM EXPOR SUAS REPRESENTAÇÃO INTERNA

  • PARA SUPORTAR MÚLTIPLAS FORMAS DE CAMINHAMENTO

  • PARA PROVER UMA INTERFACE ÚNICA PARA VARRER ESTRUTURAS AGREGADAS DIFERENTES

    • ISTO É, PARA SUPORTAR ITERAÇÃO POLIMÓRFICA

• ESTRUTURA

• EXEMPLO DE USO: UM IMPRESSOR GENÉRICO EM JAVA 1.1

class Printer {
	static void printAll(Enumeration e) {
		while(e.hasMoreElements()) {
			System.out.println(e.nextElement().toString());
		}
	}
}

class LabirintoDeRatos {
	public static void main(String[] args) {
		Vector ratos = new Vector();
		for(int i = 0; i < 3; i++ ) {
			ratos.addElement(new Rato(i));
		}
		Printer.printAll(ratos.elements()); // iterador criado aqui
	}
}

• EXEMPLO DE USO: UM IMPRESSOR GENÉRICO EM JAVA 1.2

  class Printer {
  	static void printAll(Iterator it) {
  		while(it.hasNext()) {
  			System.out.println(it.next().toString());
  		}
  	}
  }
  
  class LabirintoDeRatos {
  	public static void main(String[] args) {
  		ArrayList ratos = new ArrayList();
  		for(int i = 0; i < 3; i++ ) {
  			ratos.add(new Rato(i));
  		}
  		Printer.printAll(ratos.iterator()); // iterador criado aqui
  	}
  }

• PARTICIPANTES

  • Iterator (Enumeration em Java 1.1)

    • DEFINE A INTERFACE PARA ACESSAR E CAMINHAR NOS ELEMENTOS

  • ConcreteIterator (elements() em Java 1.1)

    • IMPLEMEMENTA A INTERFACE Iterator

    • MANTÉM ESTADO PARA SABER O ELEMENTO CORRENTE NO AGREGADO

  • Aggregate (não tem isso em Java 1.1)

    • DEFINE UMA INTERFACE PARA CRIAR UM OBJETO ITERADOR

  • ConcreteAggregate (Vector, ... em Java 1.1)

    • IMPLEMENTA A INTERFACE DE CRIAÇÃO DO ITERADOR E RETORNA UMA INSTÂNCIA DO ConcreteIterator

• CONSEQUÊNCIAS

  • A MERA SUBSTITUIÇÃO DE UM ITERADOR PERMITE CAMINHAR NUM AGRAGADO DE VÁRIAS FORMAS

  • JUNTAR A INTERFACE DE CAMINHAMENTO NUM ITERADOR PERMITE RETIRAR ESTA INTERFACE DO OBJETO AGREGADO, SIMPLIFICANDO ASSIM A INTERFACE DESTE AGREGADO

  • VÁRIAS ITERAÇÕES PODEM ESTAR OCORRENDO AO MESMO TEMPO, JÁ QUE O ESTADO DE UMA ITERAÇÃO É MANTIDO NO ITERADOR E NÃO NO AGREGADO

• DETALHES DE IMPLEMENTAÇÃO

  • ITERADORES INTERNOS VERSUS ITERADORES EXTERNOS

    • COM ITERADOR INTERNO, O CLIENTE PASSA UMA OPERAÇÃO A SER DESEMPENHADA PELO ITERADOR E ESTE O APLICA A CADA ELEMENTO

    • COM ITERADOR EXTERNO (MAIS FLEXÍVEIS),  O CLIENTE USA A INTERFACE DO ITERADOR PARA CAMINHAR MAS ELE MESMO (O CLIENTE) PROCESSA OS ELEMENTOS DO AGREGADO

    • UM ITERADOR INTERNO SÓ É USADO QUANDO UM ITERADOR EXTERNO SERIA DIFÍCIL DE IMPLEMENTAR

      • EXEMPLO: PARA AGREGADOS COMPLEXOS, MANTER O ESTADO DA ITERAÇÃO PODE SER DIFÍCIL (TERIA QUE ARMAZENAR O CAMINHO INTEIRO DENTR DE UM AGRAGADO RECURSIVO MULTI-NÍVEL). NESTE CASO, USAR UM ITERADOR INTERNO RECURSIVO E ARMAZENAR O ESTADO NA PROPRIA PILHA DE EXECUÇÃO PODE SER MAIS SIMPLES.

  • TRATAMENTO DE CONCORRÊNCIA

    • O QUE OCORRE SE HOUVER MUDANÇAS AO AGREGADO (NOVOS OBJETOS OU OBJETOS REMOVIDOS) DURANTE UMA ITERAÇÃO (DEVIDO A UM THREAD)?

    • UM "ITERADOR FAIL-FAST" INDICA IMEDIATAMENTE QUE ESTÁ HAVENDO ACESSO CONCORRENTE (VIA EXCEÇÃO)

    • ALGUNS ITERADORES PODEM CLONAR O AGREGADO PARA CAMINHAR, MAS ISTO É CARO EM GERAL

    • UM "ITERADOR ROBUSTO" PERMITE FAZER ITERAÇÕES E MUDAR O AGREGADO SEM SE PERDER

  • OPERADORES DO ITERADOR

    • PODE PERMITIR OU NÃO ANDAR PARA TRÁS, PULAR POSIÇÕES, ETC.

  • ITERADORES NULOS SÃO INTERESSANTES PARA PROVER CONDIÇOES LIMITES

    • UM ITERADOR NULO SEMPRE DIZ QUE A ITERAÇÃO ACABOU

    • EXEMPLO: SE TODO OBJETO DE UM COMPOSITE TIVER UM ITERADOR, UMA FOLHA PODERIA TER UM ITERADOR NULO

• CÓDIGO: O ITERADOR DO VECTOR EM JAVA SEGUE ABAIXO

public Enumeration elements() {
	return new Enumeration() {
		int count = 0;

		public boolean hasMoreElements() {
			return count < elementCount;
		}

		public Object nextElement() {
			synchronized (Vector.this) {
				if (count < elementCount) {
					return elementData[count++];
				}
			}
			throw new NoSuchElementException("VectorEnumeration");
		}
	};
}