1. 前言
迭代器模式（Iterator）提供了一种方法，它可以顺序访问一个对象当中的各个元素，但是又不暴露这个聚合对象的内部标示。听起来和遍历很像，个人感觉就是遍历，即是，迭代器提供了一个方法，可以顺序对象内部的某个容器，而不用知道容器中存放的是什么类型．在java中，迭代器使用非常广泛，类似于，HashSet, HashMap,ArrayList,对于它们存储的内部元素,均可以用其内部的迭代器对象进行访问。
以HashSet,写的简单的Demo,如下:
public class myClass {
public static final String NEW_LINE = "\r\n";
public static void main(String[] args){
Set<String> temp = new HashSet<>();
temp.add("11");
temp.add("22");
temp.add("33");
System.out.println(" temp ="+temp);
Iterator<String> result = temp.iterator();
while(result.hasNext()){
System.out.println("temp ="+result.next());
}
}
}
输出:
temp =[11, 22, 33]
temp =11
temp =22
temp =33
Process finished with exit code 0
这里我们可以认为，迭代器是是容器内部的一个工具，通过这个工具我们可以访问当前容器的内部元素．举一个生活中的例子，迭代器就像一辆老式公交车上的售票员，他会向每个乘客收费．
2.框架
3.案例实现
自己写一个迭代器的案例:
3.1. 抽象的虚拟类
public abstract class Iterator {
public abstract Object First();
public abstract Object end();
public abstract Object Next();
public abstract Object previous();
public abstract boolean IsDone();
public abstract boolean isDoneBackToPrevious();
public abstract Object CurrentItem();
}
3.2. 抽象的实体类:
public abstract class Aggregate {
public abstract Iterator iterator();
}
3.3.实体的迭代器类
public class ConcreteIterator extends Iterator {
public ConcreteAggregate aggregate;
public int current =0;
public ConcreteIterator(ConcreteAggregate agr){
aggregate = agr;
current = aggregate.count()-1;
}
@Override
public Object CurrentItem() {
return aggregate.getObect(current); }
@Override
public boolean IsDone() {
if (current>= aggregate.count()-1) {
return true;
} else {
return false;
}
}
@Override
public boolean isDoneBackToPrevious(){
if (current > 0) {
return true;
}
return false;
}
@Override
public Object Next() {
Object temp = null;
current++;
if (current < aggregate.count()) {
temp = aggregate.getObect(current);
}
return temp;
}
@Override
public Object previous() {
Object temp = null;
current--;
if (current >-1){
temp = aggregate.getObect(current);
}
return temp;
}
@Override
public Object end() {
return aggregate.getObect(aggregate.count()-1);
}
@Override
public Object First() {
return aggregate.getObect(0);
}
}
3.4. 实体的对象类
这个类需要使用迭代器类
public class ConcreteAggregate extends Aggregate {
private List temp = new ArrayList();
public static Iterator mIterator;
@Override
public Iterator iterator() {
return new ConcreteIterator(this);
}
public int count(){
if (temp == null) {
return 0;
} else {
return temp.size();
}
}
public Object getObect(int index){
return temp.get(index);
}
public void setObject(int index , Object value){
temp.add(index, value);
}
}
3.5. 主函数
主要的主要功能是new 对象类,然后使用其了内部的迭代器类进行实验. 这里使用倒序访问内部元素进行测试(删除部分代码,把注释的代码还原,就可以进行从正序访问)
public class myClass {
public static void main(String[] args){
ConcreteAggregate mConcreteAggregate = new ConcreteAggregate();
mConcreteAggregate.setObject(0, "zhangsan");
mConcreteAggregate.setObject(1, "lisi");
mConcreteAggregate.setObject(2, "wangwu");
mConcreteAggregate.setObject(3, 6666);
/*Obtain the Iterator like List, which is the previous example*/
Iterator mIterator = mConcreteAggregate.iterator();
// System.out.println("first item ="+mIterator.First());
// while (!mIterator.IsDone()){
// System.out.println("---"+mIterator.Next());
// }
System.out.println("last item = "+mIterator.end());
while (mIterator.isDoneBackToPrevious()) {
System.out.println(" ==="+mIterator.previous());
}
}
}
输出:
temp =[11, 22, 33]
temp =11
temp =22
temp =33
Process finished with exit code 0