Fornece uma maneira de acessar vários elementos em um objeto recipiente sem expor os detalhes internos do objeto.
Diagrama de Classe
Exemplo de código
Se você quiser perguntar o padrão mais usado em java , a resposta não é o padrão singleton, nem o padrão de fábrica, nem o padrão de estratégia, mas o padrão do iterador. Vejamos um pedaço de código primeiro:
1. public static void print(Collection coll){
2. Iterator it = coll.iterator();
3. while(it.hasNext()){
4. String str = (String)it.next();
5.
A função desse método é imprimir uma coleção de strings em um loop, que usa o modo iterador. A linguagem Java implementou totalmente o modo iterador. Iterator traduzido para o chinês significa iterador. Quando se trata de iteradores, em primeiro lugar, está relacionado a coleções. Coleções também são chamadas de agregações, contêineres, etc. Podemos considerar uma coleção como um contêiner que pode conter objetos. Por exemplo, Lista, Conjunto, Mapa e até mesmo arrays podem ser chamados de coleções. A função do iterador é percorrer os objetos no contêiner um por um .
1. interface Iterator {
2. public Object next();
3. public boolean hasNext();
4. }
5. class ConcreteIterator implements Iterator{
6. private List list = new ArrayList();
7. private int cursor =0;
8. public ConcreteIterator(List list){
9. this.list = list;
10. }
11. public boolean hasNext() {
12. if(cursor==list.size()){
13. return false;
14. }
15. return true;
16. }
17. public Object next() {
18. Object obj = null;
19. if(this.hasNext()){
20. obj = this.list.get(cursor++);
21. }
22. return obj;
23. }
24. }
25. interface Aggregate {
26. public void add(Object obj);
27. public void remove(Object obj);
28. public Iterator iterator();
29. }
30. class ConcreteAggregate implements Aggregate {
31. private List list = new ArrayList();
32. public void add(Object obj) {
33. list.add(obj);
34. }
35.
36. public Iterator iterator() {
37. return new ConcreteIterator(list);
38. }
39.
40. public void remove(Object obj) {
41. list.remove(obj);
42. }
43. }
44. public class Client {
45. public static void main(String[] args){
46. Aggregate ag = new ConcreteAggregate();
47. ag.add("小明");
48. ag.add("小红");
49. ag.add("小刚");
50. Iterator it = ag.iterator();
51. while(it.hasNext()){
52. String str = (String)it.next();
53. System.out.println(str);
54. }
55. }
56. }
No código acima, Aggregate é uma interface de classe de contêiner. Você pode imaginar Collection, List, Set, etc. Aggregate é sua versão simplificada. Existem três métodos principais na interface de classe de contêiner: add object método add, delete object method remove e get iteration器 iterador do método. Iterator é uma interface iteradora. Existem dois métodos principais: obter o método do objeto iterativo a seguir e determinar se a iteração está completa hasNext. Você pode comparar as duas interfaces java.util.List e java.util.Iterator para pensar por si mesmo.
A estrutura do padrão iterador
- Recipiente abstrato: geralmente, é uma interface que fornece um método iterator (), como a interface Collection, a interface List e a interface Set em java.
- Contêiner concreto: É a classe de realização concreta do contêiner abstrato, por exemplo, a lista ordenada da interface List implementa ArrayList, a lista vinculada da interface List implementa LinkList, a lista hash da interface Set implementa HashSet, etc.
- Iterador abstrato: define os métodos necessários para percorrer os elementos. De modo geral, existem três métodos: first () para obter o primeiro elemento, next () para obter o próximo elemento e isDone para determinar se a travessia acabou () (ou hasNext ()), o método remove () para remover o objeto atual,
- Implementação do iterador: implemente os métodos definidos na interface do iterador para completar a iteração da coleção.
Vantagens e desvantagens do padrão iterador
As vantagens do padrão iterador são:
- O método de travessia é simplificado. É ainda mais problemático percorrer a coleção de objetos. Para matrizes ou listas ordenadas, ainda podemos obtê-los por meio de cursores, mas os usuários precisam percorrer os objetos sozinhos com a premissa de ter um entendimento claro da coleção. Para a tabela hash, é mais problemático para os usuários atravessarem. Depois que o método iterador é introduzido, é muito mais simples para os usuários usarem.
- Uma variedade de métodos de travessia podem ser fornecidos. Por exemplo, para uma lista ordenada, podemos fornecer dois iteradores conforme necessário, travessia direta e travessia reversa. Os usuários só precisam obter o iterador que implementamos para realizar coletas facilmente Atravessado.
- Bom encapsulamento, os usuários só precisam fazer o iterador percorrer, mas não se preocupam com o algoritmo de passagem.
Desvantagens do padrão iterador:
- Para travessias relativamente simples (como matrizes ou listas ordenadas), usar iteradores para percorrer é mais complicado, e todos podem achar que, como ArrayList, preferiríamos usar loops for e métodos get para percorrer a coleção.
Cenários aplicáveis do modo iterador
O padrão do iterador coexiste e morre com as coleções. De modo geral, desde que implementemos uma coleção, precisamos fornecer iteradores para essa coleção ao mesmo tempo, assim como Collection, List, Set, Map, etc. em java. Essas coleções têm suas próprias O iterador. Se quisermos implementar esse novo contêiner, é claro, também precisamos introduzir o modo iterador para implementar um iterador para nosso contêiner.
No entanto, como o relacionamento entre contêineres e iteradores é muito próximo, a maioria das linguagens fornece iteradores ao implementar contêineres, e os contêineres e iteradores fornecidos por essas linguagens podem atender às nossas necessidades na maioria dos casos , Portanto, ainda é relativamente raro precisarmos praticar o modo iterador sozinhos. Precisamos apenas usar os contêineres e iteradores existentes na linguagem.