面向对象中有一些聚合对象(即一组对象的组合结构,如Java集合、数组等),迭代器模式就是为了不暴露聚合对象的内部结构的情况下,提供顺序访问聚合对象的方式。
迭代器模式:提供一个方法去顺序防问一个集合中的元素,而又不暴露这些元素的内部表示
角色分析:
抽象迭代器
具体迭代器
抽象聚合类
具体聚合类
上代码:
这个是抽象的聚合对象
public interface MyContainer {
void addElement(Object element);
void removeElement(Object element);
int getSize();
MyIterator getIterator();
}
抽象的迭代器:
public interface MyIterator {
boolean hasNext();
Object next();
}
具体的聚合类和具体的迭代器,迭代器作为集合的内部类:
public class MyContianerImpl implements MyContainer {
private Object [] elements;
private int size = 0;
private int currentSite = 0;
MyContianerImpl(int initSize){
elements = new Object[initSize];
}
@Override
public void addElement(Object element) {
if (elements.length <= currentSite){
System.out.println("集合已经满了,您要加的元素没有加进去");
}else {
this.elements[currentSite] = element;
this.currentSite++;
this.size++;
}
}
@Override
public void removeElement(Object element) {
int index = -1;
for (int i = 0 ; i < size ; i++ ){
Object item = this.elements[i];
if (item.equals(element)){
index = i;
break;
}
}
if (index != -1){
for (int j = index; j < currentSite -1; j++){
elements[j] = elements[j+1];
}
this.elements[currentSite-1] = null;
currentSite--;
size--;
} else {
System.out.println("集合中没有该元素,未删除任何元素");
}
}
@Override
public int getSize() {
return this.size;
}
@Override
public MyIterator getIterator() {
return new MyIteratorImpl();
}
private class MyIteratorImpl implements MyIterator {
int index = 0;
@Override
public boolean hasNext() {
if (this.index < currentSite){
return true;
}
return false;
}
@Override
public Object next() {
if (index < currentSite){
return elements[index++];
} else {
throw new RuntimeException("集合越界了");
}
}
}
}
测试代码:
public class ItteratorTest {
public static void main(String[] args) {
MyContainer container = new MyContianerImpl(8);
container.addElement(0);
container.addElement(1);
container.addElement(2);
container.addElement(3);
container.addElement(4);
container.addElement(5);
container.addElement(6);
container.addElement(7);
container.addElement(8); // 这个元素加不进去
MyIterator iterator = container.getIterator();
while (iterator.hasNext()){
System.out.print(iterator.next());
}
}
}
测试结果:
集合已经满了,您要加的元素没有加进去
01234567
优点:
1. 解耦,在JAVA中的迭代模式其实用的是COLLECTION继承了Iterator这个类。给自己提供了一个遍历器。我们通过自己进行创建遍历器,可以很方便。
2. 遍历的算法可以通过自己来定义。还可以定义N多种算法进行遍历。
由于引入了抽象迭代器,所以我们进行扩展的时候会比较方便,不用修改源码。符合开闭原则。
缺点:
1. 当你进行分离一个类能解决的功能的时候,就势必会增加系统类的数量!
2. 设计抽象迭代器的时候比较困难,因为需要考虑以后的如何扩展,一旦修改了抽象迭代器,那么需要修改的类一大堆(不过可以定义一个新的抽象迭代器,再由新的具体迭代器去实现)。
使用场景:
1. 需要为一个集合,(聚合对象)提供N种不同的遍历方式的时候。
2. 为不同的聚合类,提供统一的遍历方法的接口的时候。