Diferenças entre edições de "Iterador"

8 521 bytes removidos ,  01h48min de 18 de novembro de 2011
Revertendo para a revisão 27621030 de 2011-11-14 02:10:31 por Luís Felipe Braga usando popups
(Revertendo para a revisão 27621030 de 2011-11-14 02:10:31 por Luís Felipe Braga usando popups)
'''Iterator''', em [[programação de computadores]], permite a "[[Iteração|iteração]]" e um modo de acesso a elementos de um agregado de [[objeto]]s, sequencialmente, sem exposição de estruturas internas.
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.
 
Um exemplo: Considere uma lista simplesmente encadeada. Um iterador deve permitir o acesso a todos os elementos da lista de uma forma segura sem que ocorra perda de informação ou modificações não permitidas.
Segundo Eric & Elisabeth Freeman<ref>FREEMAN, Eric; FREEMAN, Elisabeth. Use a Cabeça! Padrões de Projetos. Rio de Janeiro : Alta Books, 2007.</ref>, 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<ref>NETO, Luis Francisco Thomazini. Padrões de Projetos. Faculdade de Jaguariúna. Jaguariúna, SP. Pg 24. 2006. Dispinivel em: <<http://bibdig.poliseducacional.com.br/document/?down=92>> Acesso em: 8 de Novembro de 2011.</ref>, 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<ref>CASANOVA, Paulo Tiago Gomes. Utilizando Padrões de Projeto no Desenvolvimento de Aplicações em Ambiente Web. Universidade Federal de Pelotas. Pelotas, RS. Pg 51. 2008. Disponivel em: <<http://www.ufpel.edu.br/cic/2008/cd/pages/pdf/CE/CE_01065.pdf>> Acesso em: 8 de Novembro de 2011.</ref>, 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<ref>MOTA, Guilherme Lucio Abelha; OLIVEIRA, Antônio de Pádua Albuquerque. Caderno do IME Série Informática. Rio de Janeiro. Universidade Estadual do Rio de Janeiro. Rio de Janeiro. Pg 18. Dezembro de 2010. Disponível em: <<http://www.ime.uerj.br/cadernos/cadinf/vol30/CIME_Vol30.pdf>> Acesso em: 8 de Novembro de 2011.</ref>, 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<ref>DRUZIANI, Cássio Frederico Moreira, et al. Um Estudo sobre Padrões de Projeto Aplicados a Garbage Collection. Instituto de Informática – Universidade Federal do Rio Grande do Sul. Porto Alegre, RS. Pg 5. Disponível em: <<http://inf.unisul.br/~ines/workcomp/cd/pdfs/2739.pdf>> Acesso em: 8 de Novembro de 2011.</ref>, 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'''<ref>Disponivel em: <<http://www.pg.cefetpr.br/coinf/simone/patterns/iterator.php>> Acesso em: 13/11/2011</ref> ==
 
==='''Interface Iterator'''===
 
<source lang="java">
 
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();
 
}
</source>
 
==='''Implementação da interface Iterator (IteratorConcreto)'''===
 
<source lang="java">
 
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 ;
}
 
}
 
</source>
 
==='''Interface Agregado'''===
 
<source lang="java">
package com.br.patterns.iterator;
 
 
public abstract class AbstractCollection {
abstract public Iterator CreateIterator();
}
</source>
 
==='''Implementação da Inteface Agregado(ConcreteAgregado)'''===
 
<source lang="java">
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);
}
}
 
</source>
 
==='''Classe Cliente'''===
 
<source lang="java">
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() );
}
}
}
</source>
 
=='''Refêrencias Bibliografica'''==
<references/>
 
{{esboço-programação}}
22 741

edições