一.概念
迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素,而不暴露该对象的内部方法。
二.UML
- Aggregate(集合对象抽象类)。
- ConcreteAggregate(聚合对象具体类)。里面必然有某种数据结构,能增删改查所持有的对象。
- Iterator(迭代器抽象类)。对外提供顺序访问聚合对象中对象的方法。
- ConcreteIterator(具体迭代器类)。
三.实例分析
Aggregate
package com.zzy.iterator; /** * 聚合对象抽象类 * @author eason * * @param <E> */ public interface Aggregate<E> { public Iterator<E> createIterator(); }
ArrayAggregate
package com.zzy.iterator; /** * 聚合对象抽象类,用一个数组来反映聚合对象 * @author eason * * @param <E> */ public class ArrayAggregate<E> implements Aggregate<E> { private Object[] objs; public ArrayAggregate(Object[] objs) { this.objs = objs; } public Iterator<E> createIterator() { return new ArrayIterator<E>(objs); } }
ListAggregate
package com.zzy.iterator; import java.util.List; /** * 聚合对象抽象类,用一个List来反映聚合对象 * @author eason * * @param <E> */ public class ListAggregate<E> implements Aggregate<E> { private List<E> lists; public ListAggregate(List<E> lists) { this.lists = lists; } public Iterator<E> createIterator() { return new ListIterator<E>(lists); } }
Iterator
package com.zzy.iterator; /** * 迭代器接口 * @author eason * * @param <E> */ public interface Iterator<E> { public boolean hasNext(); public E next(); }
ArrayIterator
package com.zzy.iterator; /** * 数组型迭代器 * @author eason * * @param <E> */ public class ArrayIterator<E> implements Iterator<E> { private Object[] obj; int position; public ArrayIterator(Object[] obj) { this.obj = obj; } @Override public boolean hasNext() { if(obj != null && position < obj.length) { return true; } return false; } public E next() { return (E) obj[position++]; } }
ListIterator
package com.zzy.iterator; import java.util.List; /** * List型迭代器 * @author eason * * @param <E> */ public class ListIterator<E> implements Iterator<E> { private List<E> lists; int current; public ListIterator(List<E> lists) { this.lists = lists; } @Override public boolean hasNext() { if(current < lists.size()) { return true; } return false; } @Override public E next() { return lists.get(current++); } }
TestIterator
package com.zzy.iterator; import java.util.ArrayList; import java.util.List; /** * 测试类 * @author eason * */ public class TestIterator { static String[] arrays = {"O1", "O2", "O3"}; static List<String> lists = new ArrayList<String>(); static { lists.add("L1"); lists.add("L2"); lists.add("L3"); } public static void main(String[] args) { Iterator<String> arrayIterator = new ArrayAggregate<String>(arrays).createIterator(); Iterator<String> listIterator = new ListAggregate<String>(lists).createIterator(); printIterator(arrayIterator); printIterator(listIterator); } private static void printIterator(Iterator iterator) { while(iterator.hasNext()) { System.out.println(iterator.next()); } } }
- 现在有两个聚合对象:ArrayAggregate(内部用数组来保存对象),ArrayAggregate(内部用List来保存对象)。
- 现在client想访问这两聚合对象里面的对象,会分别循环Array和List来得到结果。因为Array和List这两个数据结构本身的区别,client要分别循环Array和List。
- 这个时候,我们考虑:将“分别循环”这个操作封装在一个迭代器接口里面;并为ArrayAggregate和ArrayAggregate提供一个来得到自身迭代器的方法createIterator();并提供具体的迭代器实现类,这个就是我们要完成的部分了。
- 此时,client拿到一个聚合类,就可以得到其迭代器,从而可以得到聚合对象中的对象了。client完完全全可以不知道迭代器是怎么迭代聚合对象的。
四.使用场景及使用感受
- 迭代器模式那元素之间游走的责任从聚合对象交到了迭代器。这让聚合对象代码更加简单,让聚合对象可以更加专注在它应该专注的事情上(管理聚合对象)。
- 我们经常使用的for-each遍历,其本质是对聚合对象进行迭代。java为我们提供了迭代器类java.util.Iterator。
- 设计原则:单一责任。一个类应该只有一个引起变化的原因。通俗点就是一个类只做一件事情。
- 内聚:要来度量一个类或者模块紧密地达到一个目的或责任。当一个类或模块被设计成只支持一组相关的的功能时,我们说它具有高内聚;反正,低内聚。