`

迭代器模式

阅读更多

 

 迭代器模式遍历集合的成熟模式,迭代器模式的关键是将遍历集合的任务交给一个叫做迭代器的对象,它的工作时遍历并选择序列中的对象,而客户端程序员不必知道或关心该集合序列底层的结构。

  迭代器模式的结构中包括四种角色。

  一、集合:一个接口,规定了具体集合需要实现的操作。

  二、具体集合:具体集合石实现了集合接口的一个实例,具体的集合按照一定的结构存储对象。具体集合应该有一个方法,该方法返回一个针对该集合的具体迭代器。

  三、迭代器:一个接口,规定了遍历具体集合的方法,比如next()方法。

  四、具体迭代器:实现了迭代器接口的类的实例。具体迭代器在实现迭代器接口所规定的遍历集合的方法时,比如next()方法,要保证首次调用将按着集合的数据结构找到该集合的一个对象,并且每当找到集合中的一个对象,立即根据该集合的存储结构得到待遍历的后继对象的引用,并保证一次调用next()方法可以遍历集合。

  下列应用程序中,使用了迭代器模式中所涉及的类。该应用程序模拟点钞,使用HashSet类的实例,即一个集合模拟保险箱HashSet类的实例调用iterator()方法返回一个迭代器,用该迭代器模拟点钞机,而且在点钞过程中销毁假钞。

复制代码
 1 package com.iterator;
 2 
 3 import java.util.Collection;
 4 import java.util.HashSet;
 5 import java.util.Iterator;
 6 
 7 public class Application {
 8     public static void main(String[] args) {
 9         int n = 20;
10         int sum = 0;
11         Collection<RenMinMony> set = new HashSet<RenMinMony>();//集合对象
12         for(int i=1;i<=n;i++){
13             if(i==n/2 || i==n/5 || i==n/6){
14                 set.add(new RenMinMony(100,false));
15             }else{
16                 set.add(new RenMinMony(100,true));
17             }
18         }
19         Iterator<RenMinMony> iterator = set.iterator();
20         int jia = 0, zhen = 0;
21         System.out.println("保险箱共有"+set.size()+"张人民币!");
22         int k = 0;
23         while(iterator.hasNext()){
24             RenMinMony money = iterator.next();
25             k++;
26             if(money.isTure() == false){
27                 System.out.println("第"+k+"张是假币,被销毁");
28                 iterator.remove();//移除掉最近一次本next()返回的对象
29                 k++;
30             }
31         }
32         System.out.println("保险箱现有真人民币"+set.size()+"张,总价值是:");
33         iterator = set.iterator();
34         while(iterator.hasNext()){
35             RenMinMony money = iterator.next();
36             sum = sum + money.getValue();
37         }
38         System.out.println(sum+"元");
39     }
40 }
41 
42 class RenMinMony{
43     int value;
44     private boolean isTure;
45     public RenMinMony(int value,boolean isTure) {
46         this.value = value;
47         this.isTure = isTure;
48     }
49     public int getValue() {
50         return value;
51     }
52     public boolean isTure() {
53         return isTure;
54     }
55 }
复制代码

运行结果如下:
保险箱共有20张人民币!
第6张是假币,被销毁
第12张是假币,被销毁
第17张是假币,被销毁
保险箱现有真人民币17张,总价值是:
1700元

  迭代器优点之一:能够快速遍历集合。

  看下面的例子就能感觉出它的快速优势:

复制代码
 1 package com.iterator;
 2 
 3 import java.util.Iterator;
 4 import java.util.LinkedList;
 5 
 6 public class TestSpeed {
 7     public static void main(String[] args) {
 8         LinkedList<String> list = new LinkedList<String>();
 9         for (int i = 0; i < 60000; i++) {
10             list.add("speed"+i);
11         }
12         Iterator<String> iter = list.iterator();
13         long startTime = System.currentTimeMillis();
14         while(iter.hasNext()){
15             String te = iter.next();
16         }
17         long endTime = System.currentTimeMillis();
18         long result = endTime - startTime;
19         System.out.println("使用迭代器遍历集合的时间:"+result+"毫秒");
20         startTime = System.currentTimeMillis();
21         for (int i = 0; i < list.size(); i++) {
22             String te = list.get(i);
23         }
24         endTime = System.currentTimeMillis();
25         result = endTime - startTime;
26         System.out.println("使用get()遍历集合的时间:"+result+"毫秒");
27     }
28 }
复制代码

  迭代器的优点之二:能够实现不重新代码就可以应用于不能的容器类型。比如说原先用的事List编码的,但是后来想把相同的代码用于Set,用迭代器将会显得特别方便。

复制代码
 1 package com.iterator;
 2 
 3 import java.util.ArrayList;
 4 import java.util.HashSet;
 5 import java.util.Iterator;
 6 import java.util.LinkedList;
 7 import java.util.List;
 8 import java.util.Set;
 9 
10 public class IteratorTest {
11     public static void main(String[] args) {
12         //List<String> conn = new ArrayList<String>();
13         Set<String> conn = new HashSet<String>();
14         conn.add("aaa");
15         conn.add("aaa");
16         conn.add("bbb");
17         conn.add("ccc");
18         Iterator<String> iterator = conn.iterator();
19         while(iterator.hasNext()){
20             String a = iterator.next();
21             System.out.println(a);
22         }
23     }
24 }
复制代码

 

  下面讲一讲ListIterator

  ListIterator是一个更加强大的Iterator的子类型,但是它只能用于各种List类的访问。尽管Iterator只能向前移动,但是ListIterator可以双向移动。他还可以产生相对于迭代器在列表中指向当前位置的前一个和后一个元素的索引,并且还可以用set()方法替换掉它访问过的最后一个元素。你可以通过调用listIterator()方法产生一个指向List开始处的ListIterator,并且还可以通过调用listIterator(n)方法创建一个一开始就指向列表索引为n的元素处的ListIterator。下面的示例演示了所有这些功能:

复制代码
 1 package com.iterator;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.ListIterator;
 6 
 7 public class ListIteratorTest {
 8 
 9     public static void main(String[] args) {
10         List<Integer> list1 = new ArrayList<Integer>();
11         for (int i = 0; i <= 10; i++) {
12             list1.add(i);
13         }
14         List<Integer> list2 = new ArrayList<Integer>();
15         for (int i = 0; i <= 10; i++) {
16             list2.add(i);
17         }
18         //现在将list1的元素反序插入到list2中
19         ListIterator<Integer> it = list1.listIterator(list1.size());
20         while(it.hasPrevious()){
21             list2.add(it.previous());
22         }
23         //遍历list2
24         it = list2.listIterator();
25         while(it.hasNext()){
26             System.out.println(it.next());
27         }
28     }
29 }
复制代码
分享到:
评论

相关推荐

    设计模式之迭代器模式(Iterator)

    迭代器模式是软件设计模式中的一种行为模式,它在编程中扮演着重要的角色,尤其是在处理集合数据时。迭代器模式的核心思想是提供一种方法来顺序访问聚合对象的元素,而无需暴露其底层表示。这种模式使得用户可以在不...

    23钟设计模式之迭代器模式模式

    迭代器模式 迭代器模式是23种设计模式之一,属于行为型模式。它提供了一种访问聚合对象元素的方式,而不需要暴露该对象的内部实现。迭代器模式的主要目的是让开发者能够轻松地遍历聚合对象中的元素,而不需要关心...

    迭代器模式Demo

    迭代器模式是一种设计模式,它在软件工程中扮演着重要的角色,特别是在处理集合或容器类对象的遍历操作时。这种模式提供了一种方法来顺序访问聚合对象的元素,而无需暴露其底层表示。在Java、C#等面向对象语言中,...

    设计模式的迭代器模式的例子

    迭代器模式是软件设计模式中的一种行为模式,它允许我们顺序访问聚合对象的元素,而无需暴露其底层表示。在Java、C#等面向对象语言中,迭代器模式被广泛应用于容器类,如ArrayList、LinkedList等,使得我们可以方便...

    设计模式-迭代器模式(讲解及其实现代码)

    迭代器模式是一种行为设计模式,它提供了一种方法来顺序访问聚合对象的元素,而无需暴露其底层表示。这种模式允许我们遍历集合中的每个元素,同时保持集合本身抽象,不需了解其内部结构。 在Java、C#等面向对象语言...

    设计模式之迭代器模式

    迭代器模式是一种行为设计模式,它提供了一种方法来顺序访问聚合对象的元素,而无需暴露其底层表示。在Java中,迭代器模式是通过接口实现的,这使得我们可以遍历任何实现了`Iterable`接口的对象,例如集合框架中的`...

    设计模式(C#)之迭代器模式(Iterator Pattern)

    迭代器模式是软件设计模式中的一种行为模式,它在C#等面向对象编程语言中有着广泛的应用。这个模式的主要目标是允许用户遍历一个聚合对象(如数组、集合或列表)的所有元素,而无需了解底层的实现细节。下面将详细...

    组合模式二叉树,前序、中序、后续,迭代器模式访问遍历

    在这个主题中,我们主要探讨了如何利用组合模式(Composite Pattern)构建二叉树,并通过迭代器模式(Iterator Pattern)来实现对树的遍历,包括前序、中序和后序遍历。这些是设计模式中的经典应用,对于理解和掌握...

    迭代器模式代码示例

    迭代器模式是一种设计模式,属于行为设计模式,它允许我们顺序访问聚合对象的元素,而无需暴露其底层表示。在Java、C#等面向对象语言中,迭代器模式被广泛应用于容器类,如ArrayList、LinkedList等,使得我们可以...

    65丨迭代器模式(上):相比直接遍历集合数据,使用迭代器有哪些优势?1

    迭代器模式是一种行为设计模式,主要目的是在不暴露集合内部结构的情况下,允许外部代码遍历集合的所有元素。这种模式将遍历操作从集合类中分离出来,实现了数据结构和遍历机制的解耦。在大多数编程语言中,迭代器...

    迭代器模式demo

    迭代器模式是一种行为设计模式,它允许我们顺序访问聚合对象的元素,而无需暴露其底层表示。在Java、Python、C#等编程语言中,迭代器模式被广泛应用于集合类,如ArrayList、LinkedList等,提供了统一的遍历接口,...

    Headfirst(九)迭代器模式

    迭代器模式是一种设计模式,它提供了一种方法来顺序访问聚合对象的元素,而又不暴露其底层表示。在Headfirst的第九章中,这个模式通过C++语言进行了深入的探讨和实现,同时辅以UML类图进行可视化展示,帮助读者更好...

    (行为型模式) Iterator 迭代器模式

    ### (行为型模式) Iterator 迭代器模式 #### 概述 在软件工程领域,设计模式被广泛应用于解决常见的编程问题。其中,“迭代器模式”作为一种行为型设计模式,在处理集合类对象时发挥着重要作用。本文将详细介绍...

    java体系结构之迭代器模式.rar

    迭代器模式是软件设计模式中的一种行为模式,它允许我们顺序访问聚合对象的元素,而无需暴露其底层表示。在Java中,迭代器模式广泛应用于集合框架,如List、Set和Map接口,使得程序员可以方便地遍历集合中的元素。 ...

    【Java设计模式】(1)迭代器模式Iterator

    迭代器模式(Iterator Pattern)是Java设计模式中的行为模式之一,它提供了一种方法来顺序访问聚合对象的元素,而又不暴露其底层表示。在Java中,迭代器模式被广泛应用于集合类,如ArrayList、LinkedList等,通过...

    设计模式--迭代器模式java例子

    迭代器模式是一种行为设计模式,它允许我们顺序访问聚合对象的元素,而无需暴露其底层表示。在Java中,迭代器模式广泛应用于集合框架,如ArrayList、LinkedList等。本示例将深入探讨如何在Java中实现和使用迭代器...

    一个小小例子让你读懂迭代器模式,

    迭代器模式是软件设计模式中的一种,它在对象集合的遍历访问中起着关键作用。这个模式的主要目的是提供一种方法来顺序访问聚合对象的元素,而无需暴露其底层表示。迭代器模式允许你遍历任何聚合对象,无论它的内部...

    第20章_迭代器模式.ppt

    一个聚合对象,如一个列表(List)或者一个集合(Set),应该提供一种方法来让别人可以访问它...怎样遍历一个聚合对象,又不需要了解聚合对象的内部结构,还能够提供多种不同的遍历方式,这就是迭代器模式所要解决的问题。

Global site tag (gtag.js) - Google Analytics