1. 前言
迭代器模式(Iterator)提供了一种方法,它可以顺序访问一个对象当中的各个元素,但是又不暴露这个聚合对象的内部标示。听起来和遍历很像,个人感觉就是遍历,即是,迭代器提供了一个方法,可以顺序对象内部的某个容器,而不用知道容器中存放的是什么类型.在java中,迭代器使用非常广泛,类似于,HashSet, HashMap,ArrayList,对于它们存储的内部元素,均可以用其内部的迭代器对象进行访问。
以HashSet,写的简单的Demo,如下:
public class myClass {
public static void main(String[] args){
System.out.println("This is a good test!");
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.框架
![](https://i-blog.csdnimg.cn/blog_migrate/d0d8e313bf8003238e7873e1dc0eaec4.png)
迭代器UML图
一方面,Iterator为迭代器抽象基类,主要提供该迭代器的基本方法. ConcreteIterator 为迭代器实现类, 它内部包含了一个拥有它的对象, 通过内部方法访问对象的容器. 另外方面, Aggregate 为实体基类,内部拥有一个抽象获取的方法, ConcreteAggregate 为其实现内. 通过iterator 得到一个迭代器,以达到访问内部容器的目的.
最后, 当用户得到一个ConcreteAggregate 的一个具体对象后,通过ConcreteAggregate.iterator() 获得迭代器,然后就可以其内部元素了, 这也是我们最终希望达到的目的.
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 = 0/*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();
@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 temp = new ConcreteAggregate();
temp.setObject(0, "One");
temp.setObject(1,"Two");
temp.setObject(2, "Three");
Iterator iterator = temp.iterator();
if (iterator != null){
while (!iterator.IsDone()){
System.out.println("-------"+iterator.CurrentItem());
iterator.Next();
}
}
}
}
输出:
-------One
-------Two
-------Three
Process finished with exit code 0