使用迭代器模式来进行Java的设计模式编程

定义：提供一种方法访问一个容器对象中各个元素，而又不暴露该对象的内部细节。
类型：行为类模式
类图：

如果要问java中使用最多的一种模式，答案不是单例模式，也不是工厂模式，更不是策略模式，而是迭代器模式，先来看一段代码吧：

public static void print(collection coll){ 
  iterator it = coll.iterator(); 
  while(it.hasnext()){ 
    string str = (string)it.next(); 
    system.out.println(str); 
  } 
} 

       这个方法的作用是循环打印一个字符串集合，里面就用到了迭代器模式，java语言已经完整地实现了迭代器模式，iterator翻译成汉语就是迭代器的意思。提到迭代器，首先它是与集合相关的，集合也叫聚集、容器等，我们可以将集合看成是一个可以包容对象的容器，例如list，set，map，甚至数组都可以叫做集合，而迭代器的作用就是把容器中的对象一个一个地遍历出来。
 
迭代器模式的结构
抽象容器：一般是一个接口，提供一个iterator()方法，例如java中的collection接口，list接口，set接口等。
具体容器：就是抽象容器的具体实现类，比如list接口的有序列表实现arraylist，list接口的链表实现linklist，set接口的哈希列表的实现hashset等。
抽象迭代器：定义遍历元素所需要的方法，一般来说会有这么三个方法：取得第一个元素的方法first()，取得下一个元素的方法next()，判断是否遍历结束的方法isdone()（或者叫hasnext()），移出当前对象的方法remove(),
迭代器实现：实现迭代器接口中定义的方法，完成集合的迭代。
 
举例

　　由于迭代器模式本身的规定比较松散，所以具体实现也就五花八门。我们在此仅举一例，根本不能将实现方式一一呈现。因此在举例前，我们先来列举下迭代器模式的实现方式。

　　1．迭代器角色定义了遍历的接口，但是没有规定由谁来控制迭代。在java collection的应用中，是由客户程序来控制遍历的进程，被称为外部迭代器；还有一种实现方式便是由迭代器自身来控制迭代，被称为内部迭代器。外部迭代器要比内部迭代器灵活、强大，而且内部迭代器在java语言环境中，可用性很弱。

　　2．在迭代器模式中没有规定谁来实现遍历算法。好像理所当然的要在迭代器角色中实现。因为既便于一个容器上使用不同的遍历算法，也便于将一种遍历算法应用于不同的容器。但是这样就破坏掉了容器的封装——容器角色就要公开自己的私有属性，在java中便意味着向其他类公开了自己的私有属性。

　　那我们把它放到容器角色里来实现好了。这样迭代器角色就被架空为仅仅存放一个遍历当前位置的功能。但是遍历算法便和特定的容器紧紧绑在一起了。

　　而在java collection的应用中，提供的具体迭代器角色是定义在容器角色中的内部类。这样便保护了容器的封装。但是同时容器也提供了遍历算法接口，你可以扩展自己的迭代器。

　　好了，我们来看下java collection中的迭代器是怎么实现的吧。

//迭代器角色，仅仅定义了遍历接口

public interface iterator {
　boolean hasnext();
　object next();
　void remove();
}

//容器角色，这里以list为例。它也仅仅是一个接口，就不罗列出来了
//具体容器角色，便是实现了list接口的arraylist等类。为了突出重点这里指罗列和迭代器相关的内容
//具体迭代器角色，它是以内部类的形式出来的。abstractlist是为了将各个具体容器角色的公共部分提取出来而存在的。

public abstract class abstractlist extends abstractcollection implements list {
…… 
//这个便是负责创建具体迭代器角色的工厂方法
public iterator iterator() {
　return new itr();
}

//作为内部类的具体迭代器角色

private class itr implements iterator {
　int cursor = 0;
　int lastret = -1;
　int expectedmodcount = modcount;

　public boolean hasnext() {
　　return cursor != size();
　}

　public object next() {
　　checkforcomodification();
　　try {
　　　object next = get(cursor);
　　　lastret = cursor++;
　　　return next;
　　} catch(indexoutofboundsexception e) {
　　　checkforcomodification();
　　　throw new nosuchelementexception();
　　}
　}

　public void remove() {
　　if (lastret == -1)
　　　throw new illegalstateexception();
　　　checkforcomodification();

　　try {
　　　abstractlist.this.remove(lastret);
　　　if (lastret < cursor)
　　　　cursor--;
　　　lastret = -1;
　　　expectedmodcount = modcount;
　　} catch(indexoutofboundsexception e) {
　　　throw new concurrentmodificationexception();
　　}
　}

　final void checkforcomodification() {
　　if (modcount != expectedmodcount)
　　　throw new concurrentmodificationexception();
　}
}

　　至于迭代器模式的使用。正如引言中所列那样，客户程序要先得到具体容器角色，然后再通过具体容器角色得到具体迭代器角色。这样便可以使用具体迭代器角色来遍历容器了……

迭代器模式的优缺点
        迭代器模式的优点有：
简化了遍历方式，对于对象集合的遍历，还是比较麻烦的，对于数组或者有序列表，我们尚可以通过游标来取得，但用户需要在对集合了解很清楚的前提下，自行遍历对象，但是对于hash表来说，用户遍历起来就比较麻烦了。而引入了迭代器方法后，用户用起来就简单的多了。
可以提供多种遍历方式，比如说对有序列表，我们可以根据需要提供正序遍历，倒序遍历两种迭代器，用户用起来只需要得到我们实现好的迭代器，就可以方便的对集合进行遍历了。
封装性良好，用户只需要得到迭代器就可以遍历，而对于遍历算法则不用去关心。
        迭代器模式的缺点：
对于比较简单的遍历（像数组或者有序列表），使用迭代器方式遍历较为繁琐，大家可能都有感觉，像arraylist，我们宁可愿意使用for循环和get方法来遍历集合。
 
迭代器模式的适用场景
       迭代器模式是与集合共生共死的，一般来说，我们只要实现一个集合，就需要同时提供这个集合的迭代器，就像java中的collection，list、set、map等，这些集合都有自己的迭代器。假如我们要实现一个这样的新的容器，当然也需要引入迭代器模式，给我们的容器实现一个迭代器。
       但是，由于容器与迭代器的关系太密切了，所以大多数语言在实现容器的时候都给提供了迭代器，并且这些语言提供的容器和迭代器在绝大多数情况下就可以满足我们的需要，所以现在需要我们自己去实践迭代器模式的场景还是比较少见的，我们只需要使用语言中已有的容器和迭代器就可以了。