设计模式——迭代器模式

---

作者：云都小生

推荐学习资源

---

史上最全的设计模式导学目录

十分推荐！

概述

---

迭代器模式是比较容易理解，且使用频率非常高的一种设计模式，它的本质是 实现了数据聚合对象的存储与遍历的解耦，使数据聚合不会暴露在数据操作方法面前。

在现实的开发中，我们经常会碰到一种情况，我们需要存储许多的对象，有时候需要对这些对象进行遍历。

一般去设计的时候，都是把存储和遍历两种功能放到同一个类中，但是这样会产生许多的问题。

首先，违背了“单一职责”，每个类/方法都应该只负责一件事，聚合类既负责存储又负责遍历。

其次，违背了“封装性”，你想想看，如果存储数据和操作数据的方法放在同一个类，那么存储的数据就会都暴露出来。

设计中的角色

---

通常许多编程语言的标准库，都为我们实现了迭代器，但是为了了解迭代器的具体细节，所以我也学着去实现一下。先了解一下整个设计的框架。

抽象聚合类：该抽象类封装了一般聚合类都需要的属性和方法，它需要存储很多元素对象，所以需要内置List。它需要创建自己对应的一个迭代器，所以需要一个方法createIterator()。

具体聚合类：继承了抽象聚合类，实现了抽象聚合类的抽象方法，具体聚合类可以生成自己相对应的迭代器。

抽象迭代器：声明了迭代器对聚合数据的遍历方法，
定义了共同的属性。

具体迭代器：继承了抽象迭代器类，实现了具体的遍历方法。

案例1——独自实现迭代器

---

通过查看一些参考手册，我们知道迭代器和聚合对象通常需要一些什么属性和方法，利用抽象类封装起来。

import java.util.*;

//抽象聚合类
public abstract class AbstractAggregated {
    //该聚合数据只有子类能看到，良好的封装
    protected List<Object> objects = new ArrayList<Object>();


    public AbstractAggregated(List objects)
    {
        this.objects = objects;
    }

    //增加元素
    public void addObject(Object obj) {  
        this.objects.add(obj);  
    }  

    //删除元素
    public void removeObject(Object obj) {  
        this.objects.remove(obj);  
    }  

    //返回List
    public List getObjects() {  
        return this.objects;  
    }  

    //声明创建迭代器对象的抽象工厂方法  
    public abstract AbstractIterator createIterator(); 
}

import java.util.List;

//具体聚合类
public class TestAggregated extends AbstractAggregated {
    public TestAggregated(List objects) {  
        super(objects);  
    }  

    //实现创建迭代器对象的具体工厂方法  
    public AbstractIterator createIterator() {  
        return new TestIterator(this);  
    }  
}


public abstract class AbstractIterator {
    public abstract void next(); //移至下一个元素  
    public abstract boolean isLast(); //判断是否为最后一个元素  
    public abstract void previous(); //移至上一个元素  
    public abstract boolean isFirst(); //判断是否为第一个元素  
    public abstract Object getNextItem(); //获取下一个元素  
    public abstract Object getPreviousItem(); //获取上一个元素  
}

import java.util.*;

public class TestIterator extends AbstractIterator {
    private TestAggregated testAggregated;
    private List objects;
    private int cursor1;
    private int cursor2;

    public TestIterator(TestAggregated testAggregated) {
        this.testAggregated = testAggregated;
        this.objects = testAggregated.objects;
        if(objects.isEmpty())
        {
            cursor1 = -1;
            cursor2 = -1;
        }
        else
        {
            cursor1 = 0;
            cursor2 = objects.size()-1;
        }
    }

    //把正序游标调整到下一个元素
    public void next() {
        if(cursor1 < objects.size())
        {
            cursor1++;
        }
    }

    //判断是否是最后一个元素
    public boolean isLast() {
        return (cursor1 == objects.size());
    }

    //把逆序的游标调整到上一个元素
    public void previous() {
        if(cursor2 > -1)
        {
            cursor2--;
        }
    }

    //判断是否是第一个元素
    public boolean isFirst() {
        return (cursor2 == -1);
    }

    //获取下一个元素
    public Object getNextItem() {
        return objects.get(cursor1);  
    }

    //获取上一个元素
    public Object getPreviousItem() {
        return objects.get(cursor2);
    }
}

//客户端测试类
public class Client {
    public static void main(String[] args) {
        List objects = new ArrayList();
        objects.add("A");
        objects.add("B");
        objects.add("C");
        objects.add("D");

        AbstractAggregated list = new TestAggregated(objects);
        AbstractIterator iterator = list.createIterator();

         System.out.println("正向遍历：");      
         while(!iterator.isLast())
         {  
             System.out.print(iterator.getNextItem() + "，");  
             iterator.next();  
         }  
         System.out.println();  
         System.out.println("-----------------------------");  
         System.out.println("逆向遍历：");  
         while(!iterator.isFirst()) 
         {  
             System.out.print(iterator.getPreviousItem() + "，");  
             iterator.previous();  
         }  
    }
}

案例2——利用IDK内置的迭代器

---

我们可以直接用标准库里面的Collection和Iterator，来进行遍历。

import java.util.*;

public class Client {
    public static void main(String[] args) {
        Collection objects = new ArrayList();

        objects.add("A");
        objects.add("B");
        objects.add("C");
        objects.add("D");

        traverse(objects);
    }

    public static void traverse(Collection c)
    {
        Iterator i = c.iterator();

        while(i.hasNext())
        {
            System.out.println(i.next().toString());
        }
    }
}

总结

---

迭代器模式本质上是聚合类与迭代类之间的解耦，简化了聚合类，引入了迭代器。并且，我们还可以在掘和对象自定义多种遍历方法，符合开闭原则，可以增加新的遍历方式。

2018/1/16 16:21:48 @Author：云都小生