《大话设计模式》迭代器模式

迭代器模式（Iterator)，提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

优点：

• 支持以不同的方式遍历一个聚合对象

• 简化了聚合类

  既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

缺点：

• 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，在一定程度上增加了系统的复杂性

// 具体迭代器需实现的接口
type IteratorInterface interface {
	First() interface{}
	Next() interface{}
	IsDone() bool
	CurrentItem() interface{}
}

// 聚合"类"需实现的接口
type AggregateInterface interface {
	CreateIterator() IteratorInterface
}

// 具体聚合"类"
type Aggregate struct {
	items []interface{}
}

func (a *Aggregate) CreateIterator() IteratorInterface {
	return &Iterator{aggregate: a}
}

func (a *Aggregate) SetItems(items []interface{}) {
	a.items = items
}

func (a *Aggregate) Count() int {
	return len(a.items)
}

func (a *Aggregate) IndexOf(i int) interface{} {
	if i < 0 || i >= a.Count() {
		return nil
	}
	return a.items[i]
}

// 具体聚合类Aggregate的迭代器
type Iterator struct {
	aggregate *Aggregate
	current int
}

func (i *Iterator) First() interface{} {
	return i.aggregate.IndexOf(0)
}

func (i *Iterator) Next() interface{} {
	i.current++
	return i.aggregate.IndexOf(i.current)
}

func (i *Iterator) IsDone() bool {
	return i.current >= i.aggregate.Count()
}

func (i *Iterator) CurrentItem() interface{} {
	return i.aggregate.IndexOf(i.current)
}

func main() {
	aggregate := &Aggregate{}

	items := []interface{} {"a", "b", "c", "d", "e", "f"}
	aggregate.SetItems(items)

	iterator := aggregate.CreateIterator()
	for i := iterator.First(); !iterator.IsDone(); i = iterator.Next() {
		fmt.Println(i, iterator.CurrentItem())
	}
}
// 输出
// a a
// b b
// c c
// d d
// e e
// f f