迭代器模式是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道
集合对象的底层表示。
迭代器模式属于行为型模式。
意图：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。
主要解决：不同的方式来遍历整个整合对象。
何时使用：遍历一个聚合对象。
如何解决：把在元素之间游走的责任交给迭代器，而不是聚合对象。
关键代码：定义接口：hasNext, next。
应用实例：JAVA 中的 iterator。
优点：1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多
个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。
缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的
个数成对增加，这在一定程度上增加了系统的复杂性。
使用场景：1、访问一个聚合对象的内容而无须暴露它的内部表示。 2、需要为聚合对象提供多种遍历方式。
3、为遍历不同的聚合结构提供一个统一的接口。
注意事项：迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露
集合的内部结构，又可让外部代码透明地访问集合内部的数据。
适用性：
访问一个聚合对象的内容而无需暴露它的内部表示。
支持对聚合对象的多种遍历。
为遍历不同的聚合结构提供一个统一的接口(即，支持多态迭代)。
package iterator
// ========== Iterator ==========
type Iterator interface {
Next() string
First()
Last()
HasNext() bool
}
package iterator
// ========== IteratorImpl ==========
type IteratorImpl struct {
List []string
Index int
}
func (iteratorImpl *IteratorImpl) First() {
iteratorImpl.Index = 0
}
func (iteratorImpl *IteratorImpl) Last() {
iteratorImpl.Index = len(iteratorImpl.List) - 1
}
func (iteratorImpl *IteratorImpl) Next() string {
obj := iteratorImpl.List[iteratorImpl.Index]
iteratorImpl.Index++
return obj
}
func (iteratorImpl *IteratorImpl) HasNext() bool {
return iteratorImpl.Index < len(iteratorImpl.List)
}
package iterator
// ========== List ==========
type List interface {
Iterator() Iterator
Get(index int) string
GetSize() int
Add(str string)
}
package iterator
// ========== ListImpl ==========
type ListImpl struct {
Index int
Size int
List []string
}
func NewList() List {
return &ListImpl{Index: 0, Size: 0}
}
func (listImpl *ListImpl) Iterator() Iterator {
return &IteratorImpl{Index: 0, List: listImpl.List}
}
func (listImpl *ListImpl) Get(index int) string {
return listImpl.List[index]
}
func (listImpl *ListImpl) GetSize() int {
return len(listImpl.List)
}
func (listImpl *ListImpl) Add(str string) {
listImpl.List = append(listImpl.List, str)
}
package main
import (
"fmt"
. "proj/iterator"
)
func main() {
list := NewList()
list.Add("a")
list.Add("b")
list.Add("c")
// 第一种迭代方式
iterator := list.Iterator()
for iterator.HasNext() {
fmt.Println(iterator.Next())
}
fmt.Println("=====")
// 第二种迭代方式
for i := 0; i < list.GetSize(); i++ {
fmt.Println(list.Get(i))
}
fmt.Println("=====")
// first()和last()设置第一个元素和最后一个元素
firstIt := list.Iterator()
firstIt.First()
for firstIt.HasNext() {
fmt.Println(firstIt.Next())
}
fmt.Println("=====")
lastIt := list.Iterator()
lastIt.Last()
for lastIt.HasNext() {
fmt.Println(lastIt.Next())
}
}
# 程序输出
a
b
c
=====
a
b
c
=====
a
b
c
=====
c
package com.iterator;
// ========== Iterator ==========
public interface Iterator {
Object next();
void first();
void last();
boolean hasNext();
}
package com.iterator;
// ========== IteratorImpl ==========
public class IteratorImpl implements Iterator {
private List list;
private int index;
public IteratorImpl(List list){
index = 0;
this.list = list;
}
@Override
public void first() {
index = 0;
}
@Override
public void last() {
index = list.getSize() - 1;
}
@Override
public Object next() {
Object obj = list.get(index);
index++;
return obj;
}
@Override
public boolean hasNext() {
return index < list.getSize();
}
}
package com.iterator;
// ========== List ==========
public interface List {
Iterator iterator();
Object get(int index);
int getSize();
void add(Object obj);
}
package com.iterator;
// ========== ListImpl ==========
public class ListImpl implements List {
private Object[] list;
private int index;
private int size;
public ListImpl() {
index = 0;
size = 0;
list = new Object[100];
}
@Override
public Iterator iterator() {
return new IteratorImpl(this);
}
@Override
public Object get(int index) {
return list[index];
}
@Override
public int getSize() {
return this.size;
}
@Override
public void add(Object obj) {
list[index++] = obj;
size++;
}
}
package com.iterator;
public class Test {
public static void main(String[] arg) {
List list = new ListImpl();
list.add("a");
list.add("b");
list.add("c");
// 第一种迭代方式
Iterator it = list.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
System.out.println("=====");
// 第二种迭代方式
for (int i = 0; i < list.getSize(); i++) {
System.out.println(list.get(i));
}
System.out.println("=====");
// first()和last()设置第一个元素和最后一个元素
Iterator firstIt = list.iterator();
firstIt.first();
while (firstIt.hasNext()){
System.out.println(firstIt.next());
}
System.out.println("=====");
Iterator lastIt = list.iterator();
lastIt.last();
while (lastIt.hasNext()){
System.out.println(lastIt.next());
}
}
}
# 程序输出
a
b
c
=====
a
b
c
=====
a
b
c
=====
c