设计模式学习十三:迭代器模式
一.概念
迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素,而不暴露该对象的内部方法。
二.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。
- 设计原则:单一责任。一个类应该只有一个引起变化的原因。通俗点就是一个类只做一件事情。
- 内聚:要来度量一个类或者模块紧密地达到一个目的或责任。当一个类或模块被设计成只支持一组相关的的功能时,我们说它具有高内聚;反正,低内聚。