前言
关于什么是设计模式，在文章DesignPatterns中有过说明，本文主要讨论的是迭代器模式：
0.容器
容器的大致分类
Map：用来保存键值对.
Collection：用来保存单一元素 ： 又分为 List 、 Set 、 Queue(下图没有给出Queue的图示).
虚点框：接口，虚线框：抽象类，实线框：普通类，粗线框: 常用.
实线 ：一个类可以生成指向的那个类.
虚线：接口、抽象类之间的继承.
带有空心箭头的点线：一个抽象类实现了一个接口，或者一个接口继承于另一个接口.
带有空心箭头的实线：一个具体的类实现了一个接口，或者一个类继承于另一个类.
实心箭头的点线：一个接口可以生成另一接口，即这个接口内部必然依赖，或者说继承于箭头所指向的那个接口.
1.迭代器的由来
- 通常，在容器里会存放大量的同类型对象，如果想逐个访问容器中的对象，就必须要知道容器的结构。比如，ArrayList 和 LinkedList 的遍历方法一定是不一样的，如果再加上HashMap, TreeMap，以及BinarySearchTree等，每种不同的容器，都需要不同的方式来遍历它，对于容器的使用者而言，无疑是一个巨大的负担。那么，有没有这样一种方法，使得调用者通过这个方法就可以遍历所有的容器，而无需关心这些容器的底层实现。很明显，接口便是具有这样的功能的完美解决方案。为所有的容器能提供一个统一的接口，这个接口可以遍历容器中的所有内容，又可以把容器的细节屏蔽掉。这个接口就是 java.util.Iterator。它可以顺序访问一个集合对象中的各种元素，而又不暴露该对象的内部表示.
关于容器，集合的概念参考文章：Container(Collection)
2.迭代器的概念
An iterator is an object whose job is to move throgh a sequence and select each object in that sequence without the client programmer knowing or caring about the underlying structure of that sequence. In addition, an iterator is usually what’s called a lightweight object: one that’s cheap to create. For that reason, you’ll often find seemingly strange constraints for iterators; for example, the Java Iterator can move in only one direction. There’s not much you can do with an Iterator except:
- 1.Ask a Collection to hand you an Iterator using a method called iterator(). That Iterator will be ready to return the first element in the sequence.
- 2.Get the next object in the sequence with next().
- 3.See if there are any more objects in the sequence with hasNext().
- 4.Remove the last element returned by the iterator with remove().
迭代器是一个对象，他的工作是遍历并选择序列中的对象，而客户端程序不必知道或关心该序列底层的结构。此外，迭代器常被称为轻量级对象：创建它的代价小。因此，经常可以见到对迭代器有些奇怪的限制，例如，Java的Iterator只能单向移动，这个Iterator只能用来：
- 1.使用方法iterator()要求容器返回一个Iterator。Iterator将准备好返回序列的第一个元素。
- 2.使用 next() 获得序列中的下一个元素。
- 3.使用 hasNext() 检查序列中是否还有元素。
- 4.使用 remove() 将迭代器新近返回的元素删除。
3.迭代器模式介绍
迭代器模式：提供一种方法顺序的访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。一般情况，我们自己开发时很少自定义迭代器，因为java本身已经把迭代器做到内部中了（比如：常用的list和set中都内置了迭代器）。当然，如果真有这种需求需要我们自定义迭代器的话，可以参考jdk的迭代器实现方式来实现自己的迭代器。迭代器是可以从前往后，或者从后往前遍历的。
关于聚合的概念，参考文章：OOP
- 为遍历不同聚集结构提供如：开始，下一个，是否有下一个，是否结束，当前哪一个等等的一个统一接口。
迭代器模式UML图:
聚集类：Aggregate(抽象类)和ConcreteAggregate(具体聚集类)表示聚集类，是用来存储迭代器的数据。在Aggregate(抽象类)中有一个CreateIterator方法，用来获取迭代器.
5.代码
以下内容转载于>参考文献：7.迭代器模式-Iterator(Java实现).
迭代器模式-Iterator
- 用于访问一个集合中的各个元素, 而又不会暴露集合的内部的细节.
- 本文展示的例子就是, 在猫群组里, 用迭代器遍历每一只猫.
- 本文章的例子的继承关系图如下:
其中: - Cat就是猫的定义.
- Aggregate是"群组" “集合” 的统一抽象定义.
- CatGroup是猫群组.
- Iterator是迭代器的接口.
- CatGroupIterator是猫群组的迭代器. 用来遍历CatGroup里的每一个Cat.
如果把依赖关系加上的话, 如下:
迭代器接口
- 统一定义了迭代器该有的方法.
- hasNext() 用于判断是否还有下一个元素
- next() 用于返回下一个元素, 并且使内部计数器+1
/**
* 迭代器接口
*/
public interface Iterator {
public abstract boolean hasNext();
public abstract Object next();
}
用于生成迭代器的接口
/**
* 该接口中只有一个方法, 这个方法用于生成一个迭代器, 并返回
* <p>
* 如果某个集合想使用迭代器, 那么就就应该实现这个接口
*/
public interface Aggregate {
public abstract Iterator iterator();
}
元素类
- 本例子中举的是"猫群组"中利用迭代器来遍历每一只猫
- 所以在创建猫群组之前, 先把"猫类" 定义好
/**
* Cat是个体, 一个Cat实例代表一只猫.
* CatGroup是Cat的集合, 一个CatGroup实例代表一群猫.
*/
public class Cat {
private int age;
private String name;
public Cat(String name, int age) {
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
'}';
}
}
集合类
- 接下来创建"猫群组"类
- 猫群组类想要使用迭代器的话, 需要先实现Aggregate接口的iterator()方法, 来获提供群组的迭代器.
/**
* Cat是个体, 一个Cat实例代表一只猫.
* CatGroup是Cat的集合, 一个CatGroup实例代表一群猫.
*
* 并且这个类实现了Aggregate的iterator()方法来获取迭代器
*/
public class CatGroup implements Aggregate {
private int last;
private Cat[] cats;
public CatGroup(int maxsize) {
this.cats = new Cat[maxsize];
}
public Cat getByIndex(int index) {
return cats[index];
}
public void append(Cat cat) {
cats[last++] = cat;
}
public int getLength() {
return last;
}
@Override
public Iterator iterator() {
return new CatGroupIterator(this);
}
}
集合迭代器类
- 接下来介绍猫群组的迭代器.
- hasNext() 用于判断猫群组里是否还有下一只猫. 如果 index 小于 猫群组中猫的个数, 那么肯定有下一只; 否则, 肯定没有下一只猫, 表示已经遍历完所有猫了
- next()方法负责直接返回"下一只猫" 并且把计数器+1.
public class CatGroupIterator implements Iterator {
private int index;
private CatGroup catGroup;
public CatGroupIterator(CatGroup catGroup) {
this.catGroup = catGroup;
this.index = 0;
}
@Override
public boolean hasNext() {
return index < catGroup.getLength();
}
@Override
public Object next() {
return catGroup.getByIndex(index++);
}
}
测试
public class Main {
public static void main(String[] args) {
// 创建一个猫群
CatGroup catGroup = new CatGroup(20);
// 向猫群里添加猫
catGroup.append(new Cat("betty", 10));
catGroup.append(new Cat("nancy", 11));
catGroup.append(new Cat("wood", 14));
catGroup.append(new Cat("zira", 18));
// 获取遍历该猫群的迭代器
Iterator iterator = catGroup.iterator();
// 迭代并输出
while (iterator.hasNext()) {
Cat c = (Cat) iterator.next();
System.out.println(c);
}
}
}
- 为什么使用迭代器, 而不是使用数组+下角标的方法来遍历数组呢?
- 因为这样就可以把遍历一个集合的api进行统一. 无论是数组还是链表或者是其他集合, 都可以用迭代器来进行统一调用.
- 也就是说Iterator把一个集合的实现和遍历进行了分离.
学如不及，犹恐失之
分类: 设计模式-Java实现
6.总结
-
优点：把在元素之间游走的责任交给迭代器，而不是聚合对象。迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。
-
缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
7.专业名词解释
- 1.Iterator（抽象迭代器接口）
迭代器定义访问和遍历元素的接口 - 2.ConcreteIterator （具体迭代器）
具体迭代器实现迭代器接口，对该聚合遍历时跟踪当前位。ConcreteIterator跟踪聚合中的当前对象，并能够计算出待遍历的后继对象。 - 3.Aggregate （抽象聚合接口）
聚合定义创建相应迭代器对象的接口 - 4.ConcreteAggregate （具体聚合）
具体聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例
参考文献
以下内容转载于参考文献>1.迭代器 百度百科.
迭代器
迭代器（iterator）有时又称游标（cursor）是程序设计的软件设计模式，可在容器（container，例如链表或阵列）上遍访的接口，设计人员无需关心容器的内容。
解释
- 迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。迭代器修改了常规指针的接口，所谓迭代器是一种概念上的抽象：那些行为上像迭代器的东西都可以叫做迭代器。然而迭代器有很多不同的能力，它可以把抽象容器和通用算法有机的统一起来。
- 迭代器提供一些基本操作符：*、++、==、!=、=。这些操作和C/C++“操作array元素”时的指针接口一致。不同之处在于，迭代器是个所谓的复杂的指针，具有遍历复杂数据结构的能力。其下层运行机制取决于其所遍历的数据结构。因此，每一种容器型都必须提供自己的迭代器。事实上每一种容器都将其迭代器以嵌套的方式定义于内部。因此各种迭代器的接口相同，型号却不同。这直接导出了泛型程序设计的概念：所有操作行为都使用相同接口，虽然它们的型别不同。
功能
迭代器使开发人员能够在类或结构中支持foreach迭代，而不必整个实现IEnumerable或者IEnumerator接口。只需提供一个迭代器，即可遍历类中的数据结构。当编译器检测到迭代器时，将自动生成IEnumerable接口或者IEnumerator接口的Current，MoveNext和Dispose方法。
特点
1.迭代器是可以返回相同类型值的有序序列的一段代码；
2.迭代器可用作方法、运算符或get访问器的代码体；
3.迭代器代码使用yieldreturn语句依次返回每个元素，yield break将终止迭代；
4.可以在类中实现多个迭代器，每个迭代器都必须像任何类成员一样有惟一的名称，并且可以在foreach语句中被客户端,代码调用如下所示：foreach(int x in SimpleClass.Iterator2){}；
5.迭代器的返回类型必须为IEnumerable和IEnumerator中的任意一种；
6.迭代器是产生值的有序序列的一个语句块，不同于有一个 或多个yield语句存在的常规语句块；
7.迭代器不是一种成员，它只是实现函数成员的方式，理解这一点是很重要的，一个通过迭代器实现的成员，可以被其他可能或不可能通过迭代器实现的成员覆盖和重载；
8.迭代器块在C#语法中不是独特的元素，它们在几个方面受到限制，并且主要作用在函数成员声明的语义上，它们在语法上只是语句块而已；
9.yield关键字用于指定返回的值。到达yieldreturn语句时，会保存当前位置。下次调用迭代器时将从此位置重新开始执行。 迭代器对集合类特别有用，它提供一种简单的方法来迭代不常用的数据结构（如二进制树）。
简介
迭代器是一种检查容器内元素并遍历元素的可带泛型数据类型。
一个简单例子
#include<iostream>
using namespace std;
class _iterator
{
private:
char *p;
public:
_iterator(char*str):p(str){}
char*&operator++()
{
p+=1;//跟p++同价;
return p;
}
};
int main()
{
char *p="This is C++ program";
_iterator it(p);
cout<<"++之前："<<p<<endl;
char*p1=++it;//把地址向前加了一个char型长度,然后给指针p1
cout<<"++之后："<<p1<<endl;
return 0;
}
迭代器模式。Iterator对已集合类中的任何一个实现类，都可以返回这样一个Iterator对象。就和循环一样，好处是可以适用于任何一个类，而且实际上java对它进行了优化，比直接用index访问快一点（这一点没法考证，别人都这样说）。不过呢，有一点很好，就是用起来确实很好用，加上泛型就更好用啦。比如说这样一个例子ArrayList< String > arr = new ArrayList< String >();Iterator it = arr.iterator();迭代的时候可以这样while( it .hasNext() ){ //做一些处理，比如 System.out.print( it.next );}配合上泛型，一个好处是it.next（）可以不用类型转换。以前用的时候是Object，还要自己转，我感觉，Iterator和泛型简直就是绝配哈。
写在后面
文中如有侵权行为，请联系me。。。。。。。。。。。。。
扫一扫
138
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
