b'\n_START_ARTICLE_\nIterador\n_START_PARAGRAPH_\nEm programa\xc3\xa7\xc3\xa3o de computadores, um iterador se refere tanto ao objeto que permite ao programador percorrer um container, (uma cole\xc3\xa7\xc3\xa3o de elementos) particularmente listas, quanto ao padr\xc3\xa3o de projetos Iterator, no qual um iterador \xc3\xa9 usado para percorrer um container e acessar seus elementos. O padr\xc3\xa3o Iterator desacopla os algoritmos dos recipientes, por\xc3\xa9m em alguns casos, os algoritmos s\xc3\xa3o necessariamente espec\xc3\xadficos dos containers e, portanto, n\xc3\xa3o podem ser desacoplados._NEWLINE_V\xc3\xa1rios tipos de iteradores s\xc3\xa3o frequentemente fornecidos via uma interface de container. Embora a interface e a sem\xc3\xa2ntica de um determinado iterador s\xc3\xa3o fixas, os iteradores s\xc3\xa3o muitas vezes implementados em termos das estruturas subjacentes a uma implementa\xc3\xa7\xc3\xa3o de container e s\xc3\xa3o frequentemente acoplados ao container para permitir a sem\xc3\xa2ntica operacional do iterador. Note que um iterador segue uma rota e tamb\xc3\xa9m d\xc3\xa1 acesso a elementos de dados do container, mas n\xc3\xa3o realiza itera\xc3\xa7\xc3\xa3o (ou seja, n\xc3\xa3o tem total liberdade, como sugere sua terminologia). Um iterador \xc3\xa9 comportamentalmente semelhante ao cursor de um banco de dados. Iterators datam da linguagem de programa\xc3\xa7\xc3\xa3o CLU de 1974.\n_START_SECTION_\nIteradores externos e o padr\xc3\xa3o iterador\n_START_PARAGRAPH_\nUm iterador externo pode ser imaginado como um tipo de ponteiro que possui duas opera\xc3\xa7\xc3\xb5es prim\xc3\xa1rias: referenciar um elemento particular na cole\xc3\xa7\xc3\xa3o de objetos (chamado elemento de acesso) e modificar a si mesmo para apontar para o pr\xc3\xb3ximo elemento (chamado elemento de travessia). Tamb\xc3\xa9m deve existir uma maneira de criar um iterador para apontar para algum primeiro elemento bem como alguma maneira de determinar quando o iterador esgotou todos os elementos no container. Dependendo da linguagem e do uso pretendido, iteradores podem tamb\xc3\xa9m fornecer opera\xc3\xa7\xc3\xb5es adicionais ou exibir comportamentos diferentes._NEWLINE_O prop\xc3\xb3sito prim\xc3\xa1rio de um iterador \xc3\xa9 permitir que um usu\xc3\xa1rio processe cada elemento de um container enquanto isola o usu\xc3\xa1rio da estrutura interna de um container. Isto permite que o container armazene elementos da maneira que ele desejar permitindo que o usu\xc3\xa1rio trate-o como se ele fosse uma simples lista ou sequencia. Uma classe iterador normalmente \xc3\xa9 projetada em estreita coordena\xc3\xa7\xc3\xa3o com a classe container correspondente. Normalmente, o container fornece os m\xc3\xa9todos para cria\xc3\xa7\xc3\xa3o de iteradores._NEWLINE_Observe que um contador de loop algumas vezes \xc3\xa9 referenciado como um iterador de loop. Um contador de loop, entretanto, apenas fornece a funcionalidade de travessia e n\xc3\xa3o a funcionalidade de acesso ao elemento.\n_START_SECTION_\nGeradores\n_START_PARAGRAPH_\nUma maneira de implementar iteradores \xc3\xa9 usar um tipo especial de subrotina, conhecida como um gerador, que pode produzir valores para o seu chamador v\xc3\xa1rias vezes (em vez de retornar apenas um). A maioria dos iteradores s\xc3\xa3o naturalmente express\xc3\xadveis como geradores, mas devido aos geradores preservarem seu estado local entre as chamadas, eles s\xc3\xa3o particularmente bem adaptados para iteradores stateful complexos, como atravessadores de \xc3\xa1rvore. Um exemplo de um gerador que retorna os n\xc3\xbameros de Fibonacci usando declara\xc3\xa7\xc3\xa3o de produ\xc3\xa7\xc3\xa3o (yield) da linguagem Python pode ser visto abaixo:_NEWLINE__NEWLINE_ def fibonacci():_NEWLINE_     a, b = 0, 1_NEWLINE_     while True:_NEWLINE_         yield a_NEWLINE_         a, b = b, a+b_NEWLINE__NEWLINE_ for numero in fibonacci():  # Utiliza\xc3\xa7\xc3\xa3o do gerador como um iterador_NEWLINE_     print numero\n_START_SECTION_\nIteradores impl\xc3\xadcitos\n_START_PARAGRAPH_\nAlgumas linguagens orientadas a objetos como C#, Delphi (vers\xc3\xb5es mais recentes), Go, Java (vers\xc3\xb5es mais recentes), Lua, Perl, Python, Ruby, fornecem uma maneira intr\xc3\xadnseca de itera\xc3\xa7\xc3\xa3o atrav\xc3\xa9s de elementos de um objeto container sem a introdu\xc3\xa7\xc3\xa3o de um objeto iterador expl\xc3\xadcito. Um objeto iterador real pode existir na realidade, mas se ele existir ele n\xc3\xa3o \xc3\xa9 exposto dentro do c\xc3\xb3digo fonte da linguagem._NEWLINE_Iteradores impl\xc3\xadcitos s\xc3\xa3o geralmente manifestados por uma declara\xc3\xa7\xc3\xa3o "foreach" (ou equivalente), como no seguinte exemplo em Python:_NEWLINE_for valor in iteravel:_NEWLINE_    print valor_NEWLINE_Ou outras vezes eles podem ser criados por um objeto cole\xc3\xa7\xc3\xa3o propriamente dito, como neste exemplo em Ruby:_NEWLINE_iteravel.each do |valor|_NEWLINE_  puts valorend_NEWLINE_Este estilo de itera\xc3\xa7\xc3\xa3o \xc3\xa9 algumas vezes chamado "itera\xc3\xa7\xc3\xa3o interna" devido seu c\xc3\xb3digo executar completamente dentro do contexto do objeto iter\xc3\xa1vel (que controla todos os aspectos da itera\xc3\xa7\xc3\xa3o) e o programador apenas fornecer a opera\xc3\xa7\xc3\xa3o para executar em cada etapa (usando uma fun\xc3\xa7\xc3\xa3o an\xc3\xb4nima)._NEWLINE_As linguagens que suportam compreens\xc3\xa3o de lista ou constru\xc3\xa7\xc3\xb5es similares podem tamb\xc3\xa9m fazer uso de iteradores impl\xc3\xadcitos durante a constru\xc3\xa7\xc3\xa3o da lista de resultado, como em Python:_NEWLINE_nomes = [pessoa.nome for pessoa in lista if pessoa.feminino]_NEWLINE_Algumas vezes o natureza oculta impl\xc3\xadcita \xc3\xa9 apenas parcial. A linguagem C++ possui poucos templates de fun\xc3\xa7\xc3\xa3o, como for_each(), que permitem itera\xc3\xa7\xc3\xa3o impl\xc3\xadcita similar. Entretanto eles ainda requerem objetos interadores expl\xc3\xadcitos como sua entrada inicial. Por\xc3\xa9m uma vez inicializado a itera\xc3\xa7\xc3\xa3o subsequente ocorre implicitamente sem o uso continuado de qualquer objeto iterador exposto.\n_START_SECTION_\nJava\n_START_PARAGRAPH_\nComo sendo um padr\xc3\xa3o para percorrer listas, conjuntos, mapas etc:\xc2\xa0_NEWLINE_\xc3\x89 o que voc\xc3\xaa chamaria de "cursor" se estivesse escrevendo stored procedures em algum banco SQL. Portanto n\xc3\xa3o \xc3\xa9 um conceito novo ou extraordinariamente dif\xc3\xadcil de manipular.\xc2\xa0_NEWLINE_Se voc\xc3\xaa sabe que o seu List \xc3\xa9 um ArrayList, ent\xc3\xa3o n\xc3\xa3o h\xc3\xa1 problemas em usar o \xc3\xadndice em vez de usar um Iterator. Para todos os outros tipos (LinkedList, Set, Map etc.) voc\xc3\xaa tem de usar o Iterator.\xc2\xa0_NEWLINE_E de qualquer maneira voc\xc3\xaa continua a usar o for:_NEWLINE_// digamos que cole\xc3\xa7\xc3\xa3o seja uma cole\xc3\xa7\xc3\xa3o de BlaBleBlifor (Iterator it = colecao.iterator() it.hasNext()) {_NEWLINE_  BlaBleBli obj = (BlaBleBli) it.next();}_NEWLINE_Em Java 5, o "iterator" pode at\xc3\xa9 ficar escondido:_NEWLINE_for (BlaBleBli obj : colecao) {_NEWLINE_No exemplo abaixo temos a classe principal MenuItem que \xc3\xa9 simplesmente um item de um menu que possui um nome, este poderia ser um menu que apareceria na se\xc3\xa7\xc3\xa3o de menu de um site, por exemplo._NEWLINE_class MenuItem {_NEWLINE_  String nome;_NEWLINE__NEWLINE_  MenuItem(String nome) {_NEWLINE_    this.nome = nome;_NEWLINE_  }}interface Iterator {_NEWLINE_  boolean hasNext();_NEWLINE_  Object next();}public class MenuIterator implements Iterator {_NEWLINE_  MenuItem[] itens;_NEWLINE_  int posicao = 0;_NEWLINE__NEWLINE_  public MenuIterator(MenuItem[] itens) {_NEWLINE_    this.itens = itens;_NEWLINE_  }_NEWLINE__NEWLINE_  public Object next() {_NEWLINE_    MenuItem menuItem = itens[posicao];_NEWLINE_    posicao++;_NEWLINE_    return menuItem;_NEWLINE_  }_NEWLINE__NEWLINE_  public boolean hasNext() {_NEWLINE_    if (posicao >= itens.length || itens[posicao] == null) {_NEWLINE_      return false;_NEWLINE_    }_NEWLINE_    return true;_NEWLINE_  }}\n_START_SECTION_\nPython\n_START_PARAGRAPH_\nIteradores em Python s\xc3\xa3o uma parte fundamental da linguagem e em muitos casos passam despercebidos, pois s\xc3\xa3o utilizados implicitamente na declara\xc3\xa7\xc3\xa3o for (foreach), em compreens\xc3\xb5es de listas e em express\xc3\xb5es geradoras. Todos os tipos de cole\xc3\xa7\xc3\xa3o padr\xc3\xb5es nativos de Python suportam itera\xc3\xa7\xc3\xa3o, bem como muitas classes que s\xc3\xa3o parte da biblioteca padr\xc3\xa3o. O seguinte exemplo mostra uma itera\xc3\xa7\xc3\xa3o impl\xc3\xadcita t\xc3\xadpica sobre uma sequ\xc3\xaancia:_NEWLINE__NEWLINE_ for valor in sequencia:_NEWLINE_     print(valor)_NEWLINE_Dicion\xc3\xa1rios Python (uma forma de matriz associativa) tamb\xc3\xa9m podem ser iterados diretamente, quando as chaves de dicion\xc3\xa1rio s\xc3\xa3o retornadas; ou o m\xc3\xa9todo items de um dicion\xc3\xa1rio pode ser iterado sobre onde ele produz pares chave,valor correspondentes como uma tupla:_NEWLINE_for chave in dicionario:_NEWLINE_    valor = dicionario[chave]_NEWLINE_    print(chave, valor)_NEWLINE_for chave, valor in dicionario.items():_NEWLINE_    print(chave, valor)_NEWLINE_Iteradores no entanto podem ser usados e definidos explicitamente. Para qualquer tipo de seq\xc3\xbc\xc3\xaancia iter\xc3\xa1vel ou classe, a fun\xc3\xa7\xc3\xa3o nativa iter() \xc3\xa9 usada para criar um objeto iterador. O objeto iterador pode ent\xc3\xa3o ser iterado com a fun\xc3\xa7\xc3\xa3o next(), que usa o m\xc3\xa9todo __ next__ () internamente, que retorna o pr\xc3\xb3ximo elemento no recipiente. (A declara\xc3\xa7\xc3\xa3o anterior \xc3\xa9 aplic\xc3\xa1vel em Python 3.x. Em Python 2.x, o m\xc3\xa9todo next() \xc3\xa9 equivalente.) Uma exce\xc3\xa7\xc3\xa3o StopIteration ser\xc3\xa1 lan\xc3\xa7ada quando n\xc3\xa3o restarem mais elementos. O exemplo a seguir mostra uma itera\xc3\xa7\xc3\xa3o sobre uma seq\xc3\xbc\xc3\xaancia equivalente usando iteradores expl\xc3\xadcitos:_NEWLINE_it = iter(sequencia)while True:_NEWLINE_    try:_NEWLINE_        valor = it.next() # em Python 2.x_NEWLINE_        valor = next(it) # em Python 3.x_NEWLINE_    except StopIteration:_NEWLINE_        break_NEWLINE_    it = iter(it)_NEWLINE_    print(valor)_NEWLINE_Qualquer classe definida pelo usu\xc3\xa1rio pode suportar itera\xc3\xa7\xc3\xa3o padr\xc3\xa3o (impl\xc3\xadcita ou expl\xc3\xadcita), pela defini\xc3\xa7\xc3\xa3o de um m\xc3\xa9todo __iter__() que retorna um objeto iterador. O objeto iterador, ent\xc3\xa3o, precisa definir um m\xc3\xa9todo __next__() que retorna o pr\xc3\xb3ximo elemento e um m\xc3\xa9todo __iter__() que retorna o pr\xc3\xb3ximo objeto iterador a ser usado._NEWLINE_Geradores do Python implementam este protocolo de itera\xc3\xa7\xc3\xa3o.'