设计模式：迭代器模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）
上一篇《装饰器模式》 下一篇《中介者模式》
简介：
迭代器模式，它是一种行为型设计模式，它定义了如何通过迭代器对象来顺序访问聚合对象中的每一个元素，而不需要暴露该对象的内部表示。在面向对象编程中，这种模式可以使开发人员透过特定的接口巡访容器中的每一个元素，而无需了解底层实现。
迭代器模式主要包含以下四个角色：
1、抽象聚合（Aggregate）角色：定义存储、添加、删除聚合元素以及创建迭代器对象的接口。
2、具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
3、抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、next() 等方法。
4、具体迭代器（ConcreteIterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。
迭代器模式的使用场景：
1、需要遍历一个容器，如集合、数组等，但不想暴露其内部表示时。
2、需要抽象出不同的遍历方式，以支持对同一个聚合对象进行多种方式的遍历时。
3、需要支持对容器中元素进行复杂操作，如过滤、映射等，而不仅仅是简单的遍历时。
总之，迭代器模式适用于需要在不暴露容器内部表示的情况下，对容器中的元素进行遍历、操作等操作的情况。
迭代器模式的创建步骤：
1、创建一个抽象的迭代器类（Iterator），它定义了访问和遍历元素的接口，包括moveToMinusOne()、moveToFirst()、next()、hasNext()等方法。
2、创建一个抽象的容器类（Aggregate），它用于存储和管理元素对象，声明一个用于创建一个迭代器对象的方法，充当抽象迭代器工厂角色。
3、创建一个具体的聚合类（ConcreteAggregate），它实现抽象聚合类中定义的接口和方法。
4、创建一个具体的迭代器类（ConcreteIterator），它实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。
以上步骤是创建迭代器模式的基本步骤，但需要注意的是，不同的应用场景可能需要不同的具体实现方式，需要根据实际情况进行调整。
迭代器模式的优点，主要包括：
1、分离了集合对象的遍历行为，降低了聚合类的复杂性。
2、抽象出了迭代器负责集合对象的遍历，让外部的代码能够透明地访问集合内部的数据。
3、支持以不同的方式遍历一个聚合对象，在一个聚合对象中可以定义多种遍历方式。
4、简化了聚合类的设计。
5、增加新的聚合类和迭代器类方便，符合开闭原则。
迭代器模式的缺点，主要包括：
1、类的个数成对增加：如果新添加一个集合类，需要增加该集合类对应的迭代器类，类的个数成对增加，在一定程度上增加了系统复杂性。
2、抽象迭代器的设计难度较大，需要充分考虑系统将来的发展。
3、需要为一个聚合对象提供多种遍历方式。
示例：
一、C#迭代器模式
以下是一个示例，展示了如何在C#中实现迭代器模式：
public interface ICollection
{
IEnumerator GetEnumerator();
}
public class ConcreteCollection : ICollection
{
private List list = new List();
public void Add(T item)
{
list.add(item);
}
public IEnumerator GetEnumerator()
{
return list.GetEnumerator();
}
}
public abstract class Iterator
{
protected T current;
public bool HasNext()
{
throw new NotImplementedException();
}
public T Next()
{
throw new NotImplementedException();
}
}
public class ConcreteIterator : Iterator
{
private List list;
private int index = 0;
public ConcreteIterator(List list)
{
this.list = list;
}
public override bool HasNext()
{
return index < list.Count;
}
public override T Next()
{
current = list[index];
index++;
return current;
}
}
public class Example
{
static void Main()
{
ICollection collection = new ConcreteCollection();
collection.Add(1);
collection.Add(2);
collection.Add(3);
IEnumerator enumerator collection.GetEnumerator();
foreach (int num in enumerator)
{
Console.WriteLine(num);
}
}
} 二、java迭代器模式
迭代器模式通常通过以下方式实现：
interface Iterator {
boolean hasNext();
T next();
}
abstract class Aggregate {
abstract Iterator createIterator();
}
class ConcreteAggregate extends Aggregate {
private List list = new ArrayList();
public void add(T item) {
list.add(item);
}
@Override
Iterator createIterator() {
return new ConcreteIterator(list);
}
}
class ConcreteIterator implements Iterator {
private List list;
private int index = 0;
public ConcreteIterator(List list) {
this.list = list;
}
@Override
public boolean hasNext() {
return index < list.size();
}
@Override
public T next() {
if (hasNext()) {
return list.get(index++);
} else {
throw new NoSuchElementException();
}
}
}
//实例应用
public class Main {
public static void main(String[] args) {
Aggregate aggregate = new ConcreteAggregate();
aggregate.Add(1);
aggregate.Add(2);
aggregate.Add(3);
Iterator iterator = aggregate.createIterator();
System.out.println(iterator.next());
}
} 三、javascript迭代器模式
在JavaScript中，迭代器模式通常涉及以下角色：
1、迭代器对象（Iterator）：具有next()方法的对象，该方法返回一个包含两个属性的对象：value和done。value属性包含当前元素的值，done属性是一个布尔值，指示是否已经完成迭代。
2、聚合对象（Aggregate）：具有创建迭代器对象的方法。
下面是一个简单的JavaScript迭代器模式示例：
javascript
// 定义一个聚合对象
class Aggregate {
constructor(data) {
this.data = data;
}
createIterator() {
return new Iterator(this.data);
}
}
// 定义一个迭代器对象
class Iterator {
constructor(data) {
this.data = data;
this.index = 0;
}
next() {
if (this.hasNext()) {
return { value: this.data[this.index++], done: false };
} else {
return { done: true };
}
}
hasNext() {
return this.index < this.data.length;
}
}
// 使用示例
const aggregate = new Aggregate([1, 2, 3, 4, 5]);
const iterator = aggregate.createIterator();
console.log(iterator.next().value); // 1
console.log(iterator.next().value); // 2
console.log(iterator.next().value); // 3
console.log(iterator.next().value); // 4
console.log(iterator.next().value); // 5
console.log(iterator.next().done); // true四、C++迭代器模式
以下是在C++中实现迭代器模式：
#include
#include
// 迭代器接口
template
class Iterator {
public:
virtual bool hasNext() const = 0;
virtual T next() = 0;
};
// 具体迭代器类
template
class ConcreteIterator : public Iterator {
private:
std::list& list;
typename std::list::iterator it;
public:
ConcreteIterator(std::list& lst) : list(lst), it(lst.begin()) {}
bool hasNext() const override { return it != list.end(); }
T next() override { return *it++; }
};
// 聚合类
template
class Aggregate {
public:
virtual Iterator* createIterator() const = 0;
};
// 具体聚合类
template
class ConcreteAggregate : public Aggregate {
private:
std::list data;
public:
ConcreteAggregate(std::list& lst) : data(lst) {}
Iterator* createIterator() const override { return new ConcreteIterator(data); }
};
int main() {
std::list lst = {1, 2, 3, 4, 5};
ConcreteAggregate agg(lst);
ConcreteIterator* iter = agg.createIterator();
while (iter->hasNext()) {
std::cout << iter->next() << " ";
}
std::cout << std::endl;
delete iter;
return 0;
}
五、python迭代器模式
以下是在python中实现迭代器模式：
class Iterator:
def __init__(self):
self.items = []
def add(self, item):
self.items.append(item)
def __iter__(self):
return self
def __next__(self):
if not self.items:
raise StopIteration
return self.items.pop(0)
class ConcreteIterator(Iterator):
def __init__(self, start, end):
super().__init__()
self.start = start
self.end = end
def add(self, item):
if item < self.end:
super().add(item)
def __next__(self):
if not self.items or self.items[-1] >= self.end:
raise StopIteration
return self.items.pop(0)
if __name__ == '__main__':
iterator = ConcreteIterator(1, 5)
for item in iterator:
print(item) 六、go迭代器模式
在Go语言中，迭代器模式被广泛使用，但Go本身并没有提供像Python或Java那样的内置迭代器接口。相反，Go开发者通过使用函数和方法来创建迭代器。
以下是一个在Go中实现迭代器模式的简单示例：
package main
import "fmt"
// 定义一个容器类型
type Container struct {
items []int
}
// 定义一个迭代器方法
func (c *Container) Iterator() func() (int, bool) {
index := 0
return func() (int, bool) {
if index < len(c.items) {
result := c.items[index]
index++
return result, true
} else {
return 0, false
}
}
}
func main() {
container := Container{items: []int{1, 2, 3, 4, 5}}
iterator := container.Iterator() // 创建一个迭代器
for item, ok := iterator(); ok; item, ok = iterator() {
fmt.Println(item) // 输出每个元素
}
}七、PHP迭代器模式
以下是一个示例，展示了如何在PHP中实现迭代器模式：
//定义聚合类：创建一个聚合类，该类将包含要迭代访问的元素。
class Aggregate {
private $items;
public function __construct() {
$this->items = [];
}
public function add($item) {
$this->items[] = $item;
}
public function getIterator() {
return new Iterator($this->items);
}
}
//定义迭代器类：创建一个迭代器类，该类将实现SeekableIterator接口，以便能够使用seek()方法来设置迭代器的位置。
class Iterator implements SeekableIterator {
private $items;
private $position;
public function __construct(array $items) {
$this->items = $items;
$this->position = 0;
}
public function current() {
return $this->items[$this->position];
}
public function next() {
$this->position++;
}
public function key() {
return $this->position;
}
public function valid() {
return isset($this->items[$this->position]);
}
public function seek($position) {
$this->position = $position;
}
}
//使用聚合类和迭代器类进行迭代：创建一个聚合对象，并使用getIterator()方法获取迭代器对象。然后，使用foreach循环或直接调用迭代器的current()方法来遍历聚合对象的元素。
$aggregate = new Aggregate();
$aggregate->add('foo');
$aggregate->add('bar');
$aggregate->add('baz');
$iterator = $aggregate->getIterator();
foreach ($iterator as $item) {
echo $item . "\n"; // 输出每个元素并换行
}《完结》
上一篇《装饰器模式》 下一篇《中介者模式》