迭代器模式
迭代器是一种模式，它可以使得对于序列类型的数据结构的遍历行为与被遍历的对象分离，即我们无需关心该序列的底层结构是什么样子的。只要拿到这个对象,使用迭代器就可以遍历这个对象的内部.
1.Iterator
Java提供一个专门的迭代器<<interface>>Iterator，我们可以对某个序列实现该interface，来提供标准的Java迭代器。Iterator接口实现后的功能是“使用”一个迭代器.
文档定义:
- Package java.util;
- public interface Iterator<E> {
- boolean hasNext();//判断是否存在下一个对象元素
- E next();
- void remove();
- }
2.Iterable
Java中还提供了一个Iterable接口，Iterable接口实现后的功能是“返回”一个迭代器,我们常用的实现了该接口的子接口有: Collection<E>, Deque<E>, List<E>, Queue<E>, Set<E> 等.该接口的iterator()方法返回一个标准的Iterator实现。实现这个接口允许对象成为 Foreach 语句的目标。就可以通过Foreach语法遍历你的底层序列。
Iterable接口包含一个能够产生Iterator的iterator()方法，并且Iterable接口被foreach用来在序列中移动。因此如果创建了任何实现Iterable接口的类，都可以将它用于foreach语句中。
- 文档定义:
- Package java.lang;
- import java.util.Iterator;
- public interface Iterable<T> {
- Iterator<T> iterator();
- }
- 使用Iterator的简单例子
- import java.util.*;
- public class TestIterator {
- public static void main(String[] args) {
- List list=new ArrayList();
- Map map=new HashMap();
- for(int i=0;i<10;i++){
- list.add(new String("list"+i) );
- map.put(i, new String("map"+i));
- }
- Iterator iterList= list.iterator();//List接口实现了Iterable接口
- while(iterList.hasNext()){
- String strList=(String)iterList.next();
- System.out.println(strList.toString());
- }
- Iterator iterMap=map.entrySet().iterator();
- while(iterMap.hasNext()){
- Map.Entry strMap=(Map.Entry)iterMap.next();
- System.out.println(strMap.getValue());
- }
- }
- }
- <span style="font-size:18px;color:#000099;"> </span><span style="font-size:18px;color:#000099;"></span>
接口Iterator在不同的子接口中会根据情况进行功能的扩展,例如针对List的迭代器ListIterator,该迭代器只能用于各种List类的访问。ListIterator可以双向移动。添加了previous()等方法.
3 Iterator与泛型搭配
Iterator对集合类中的任何一个实现类，都可以返回这样一个Iterator对象。可以适用于任何一个类。
因为集合类(List和Set等)可以装入的对象的类型是不确定的,从集合中取出时都是Object类型,用时都需要进行强制转化,这样会很麻烦,用上泛型,就是提前告诉集合确定要装入集合的类型,这样就可以直接使用而不用显示类型转换.非常方便.
4.foreach和Iterator的关系
for each是jdk5.0新增加的一个循环结构，可以用来处理集合中的每个元素而不用考虑集合定下标。
格式如下
for(variable:collection){ statement; }
定义一个变量用于暂存集合中的每一个元素，并执行相应的语句(块)。collection必须是一个数组或者是一个实现了lterable接口的类对象。
- 上面的例子使用泛型和forEach的写法:
- import java.util.*;
- public class TestIterator {
- public static void main(String[] args) {
- List<String> list=new ArrayList<String> ();
- for(int i=0;i<10;i++){
- list.add(new String("list"+i) );
- }
- for(String str:list){
- System.out.println(str);
- }
- }
可以看出,使用for each循环语句的优势在于更加简洁，更不容易出错，不必关心下标的起始值和终止值。
forEach不是关键字,关键字还是for,语句是由iterator实现的，他们最大的不同之处就在于remove()方法上。
一般调用删除和添加方法都是具体集合的方法，例如：
List list = new ArrayList(); list.add(...); list.remove(...);
但是，如果在循环的过程中调用集合的remove()方法，就会导致循环出错，因为循环过程中list.size()的大小变化了，就导致了错误。 所以，如果想在循环语句中删除集合中的某个元素，就要用迭代器iterator的remove()方法，因为它的remove()方法不仅会删除元素，还会维护一个标志，用来记录目前是不是可删除状态，例如，你不能连续两次调用它的remove()方法，调用之前至少有一次next()方法的调用。
forEach就是为了让用iterator循环访问的形式简单，写起来更方便。当然功能不太全,所以但如有删除操作，还是要用它原来的形式。
4 使用for循环与使用迭代器iterator的对比
效率上的各有有事
采用ArrayList对随机访问比较快，而for循环中的get()方法，采用的即是随机访问的方法，因此在ArrayList里，for循环较快
采用LinkedList则是顺序访问比较快，iterator中的next()方法，采用的即是顺序访问的方法，因此在LinkedList里，使用iterator较快
从数据结构角度分析,for循环适合访问顺序结构,可以根据下标快速获取指定元素.而Iterator 适合访问链式结构,因为迭代器是通过next()和Pre()来定位的.可以访问没有顺序的集合.
而使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素，而不用考虑集合类的内部实现（只要它实现了 java.lang.Iterable 接口），如果使用 Iterator 来遍历集合中元素，一旦不再使用 List 转而使用 Set 来组织数据，那遍历元素的代码不用做任何修改，如果使用 for 来遍历，那所有遍历此集合的算法都得做相应调整,因为List有序,Set无序,结构不同,他们的访问算法也不一样.
定义：提供一种方法访问一个容器对象中各个元素，而又不暴露该对象的内部细节。
类型：行为类模式
类图：
如果要问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(),
- 迭代器实现：实现迭代器接口中定义的方法，完成集合的迭代。
代码实现
- //抽象迭代器接口
- interface Iterator {
- public Object next();
- public boolean hasNext();
- }
-
- //具体迭代器
- class ConcreteIterator implements Iterator
- {
- private List list = new ArrayList();
- private int cursor =0;
- public ConcreteIterator(List list){
- this.list = list;
- }
- public boolean hasNext() {
- if(cursor==list.size()){
- return false;
- }
- return true;
- }
- public Object next() {
- Object obj = null;
- if(this.hasNext()){
- obj = this.list.get(cursor++);
- }
- return obj;
- }
- }
- interface Aggregate {
- public void add(Object obj);
- public void remove(Object obj);
- public Iterator iterator();
- }
- class ConcreteAggregate implements Aggregate {
- private List list = new ArrayList(); //容器中存放的对象保存在list中
- public void add(Object obj) // 添加对象到容器中
- {
- list.add(obj);
- }
- public Iterator iterator() //获取迭代器
- {
- return new ConcreteIterator(list);
- }
- public void remove(Object obj) //从容器中移除对象
- {
- list.remove(obj);
- }
- }
- public class Client {
- public static void main(String[] args){
- Aggregate ag = new ConcreteAggregate();
- ag.add("小明");
- ag.add("小红");
- ag.add("小刚");
- Iterator it = ag.iterator(); //通过迭代器访问ag中的元素，而不暴漏ag对象的结构
- while(it.hasNext()){
- String str = (String)it.next();
- System.out.println(str);
- }
- }
- }
上面的代码中，Aggregate是容器类接口，大家可以想象一下Collection，List，Set等，Aggregate就是他们的简化版，容器类接口中主要有三个方法：添加对象方法add、删除对象方法remove、取得迭代器方法iterator。Iterator是迭代器接口，主要有两个方法：取得迭代对象方法next，判断是否迭代完成方法hasNext，大家可以对比java.util.List和java.util.Iterator两个接口自行思考。
迭代器模式的优缺点
迭代器模式的优点有：
- 简化了遍历方式，对于对象集合的遍历，还是比较麻烦的，对于数组或者有序列表，我们尚可以通过游标来取得，但用户需要在对集合了解很清楚的前提下，自行遍历对象，但是对于hash表来说，用户遍历起来就比较麻烦了。而引入了迭代器方法后，用户用起来就简单的多了。
- 可以提供多种遍历方式，比如说对有序列表，我们可以根据需要提供正序遍历，倒序遍历两种迭代器，用户用起来只需要得到我们实现好的迭代器，就可以方便的对集合进行遍历了。
- 封装性良好，用户只需要得到迭代器就可以遍历，而对于遍历算法则不用去关心。
迭代器模式的缺点：
- 对于比较简单的遍历（像数组或者有序列表），使用迭代器方式遍历较为繁琐，大家可能都有感觉，像ArrayList，我们宁可愿意使用for循环和get方法来遍历集合。
迭代器模式的适用场景
迭代器模式是与集合共生共死的，一般来说，我们只要实现一个集合，就需要同时提供这个集合的迭代器，就像java中的Collection，List、Set、Map等，这些集合都有自己的迭代器。假如我们要实现一个这样的新的容器，当然也需要引入迭代器模式，给我们的容器实现一个迭代器。
但是，由于容器与迭代器的关系太密切了，所以大多数语言在实现容器的时候都给提供了迭代器，并且这些语言提供的容器和迭代器在绝大多数情况下就可以满足我们的需要，所以现在需要我们自己去实践迭代器模式的场景还是比较少见的，我们只需要使用语言中已有的容器和迭代器就可以了。
