角色剖析:
集合(Aggregate):一个接口,规定了具体集合需实现的操作。
具体集合(ConcreteAggregate):具体集合是实现集合接口的类的实例,具体集合按着一定结构存储对象。具体集合应当有一个方法,该方法返回一个针对该集合的具体迭代器。
迭代器(Iterator):一个接口,规定了遍历具体集合的方法。
具体迭代器(ConcreteIterator):实现迭代器接口的类的实例,要保证遍历集合时,首次调用将按着集合的数据结构找到该集合中的一个对象,而且每当找到集合中的一个对象,立刻根据该集合的存储结构得到待遍历的后继对象的引用( new 具体迭代器() )。
示例代码:
迭代器:
java.util包中的Iterator接口,该接口有:
boolean hasNext()
Object next()
void remove()
三个方法。通过调用hasNext()判断集合中是否还有对象未被next()返回,调用remove()从集合中删除最近一次调用next()返回的对象。
集合:
public interface College1 {
public void addDepartment(String desc);
public Iterator createIterator();
}
具体集合:
public class ComputerCollege1 implements College1{
Department[] departments;
int mun=0;
ComputerCollege1() {
departments=new Department[6];
addDepartment("JAVA");
addDepartment("JAVAEE");
addDepartment("JS");
}
@Override
public void addDepartment(String desc) {
Department department=new Department(desc);
departments[mun]=department;
mun++;
}
@Override
public Iterator createIterator() {
return new ComputerIterator1(departments);
}
}
public class InfoCollege1 implements College1{
List<Department> departmentlist;
public InfoCollege1() {
departmentlist=new ArrayList<Department>();
addDepartment("数学");
addDepartment("语文");
}
@Override
public void addDepartment(String desc) {
Department department=new Department(desc);
departmentlist.add(department);
}
@Override
public Iterator createIterator() {
return new InfomationIterator1(departmentlist);
}
}
具体迭代器:
public class ComputerIterator1 implements Iterator{
Department[] departments;
int position=0;
public ComputerIterator1(Department[] departments) {
this.departments=departments;
}
@Override
public boolean hasNext() {
if(departments.length<=position||departments[position]==null) {
return false;
}else {
return true;
}
}
@Override
public Object next() {
Department department=departments[position];
position+=1;
return department;
}
public void remove() {}
}
public class InfomationIterator1 implements Iterator{
List<Department> delist;
int index=-1;
public InfomationIterator1(List<Department> delist) {
this.delist=delist;
}
@Override
public boolean hasNext() {
if(index>=delist.size()-1) {
return false;
}else {
index+=1;
return true;
}
}
@Override
public Object next() {
return delist.get(index);
}
}
测试类:
public class OutPutImpl {
List<College1> colleges;//集合
public OutPutImpl(List<College1> colleges) {
super();
this.colleges = colleges;
}
public void printCollege() {
//从colleges去除所有学院
Iterator<College1> iterator=colleges.iterator();
while(iterator.hasNext()) {
//取出一个学院
College next= iterator.next();
printDepartment(next.createIterator());//得到对应的迭代器
}
}
public void printDepartment(Iterator iterator) {
while(iterator.hasNext()) {
Department d= (Department) iterator.next();
System.out.println(d.getDesc());
}
}
}
public class Department {//通过这个类将所需要的集合内容加到具体集合中
private String desc;//系的描述
public Department(String desc) {
super();
this.desc = desc;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
}
public class Client3 {
public static void main(String[] args) {
ArrayList<College1> colleges=new ArrayList<College1>();//集合对象
ComputerCollege1 college=new ComputerCollege1();//具体集合
InfoCollege1 infoCollege=new InfoCollege1();//具体集合
colleges.add(college);
colleges.add(infoCollege);
OutPutImpl outPutImpl=new OutPutImpl(colleges);
outPutImpl.printCollege();
}
}
总结:
定义:提供一种方法顺序访问一个聚合对象中的各个元素,而又不需要暴露该对象的内部表示(对用户而言)。
核心:将集合的遍历行为抽取出来变成单独的迭代器对象。
优点:
- 将客户端与具体集合解耦,客户端通过迭代器和集合依赖子类。
- 用户使用迭代器访问集合中的对象,而不需要知道这些对象在集合中是如何表示和存储的。
- 用户可以同时使用多个迭代器遍历一个集合。
适合使用迭代器模式的情景
- 让用户访问一个集合中的对象,但不想暴露对象在集合中的存储结构。
- 希望对遍历不同的集合提供一个统一的接口。
缺点:每个聚合对象都要一个迭代器,多个迭代器不好管理类。