迭代器模式的基本概念

首先迭代器模式其实可以分为四个角色

• 角色一：Iterator（迭代器接口）->协议 作用：定义了访问遍历元素的方法
• 角色二：ConcreteIterator（具体迭代器）作用：遍历具体元素方法实现
• 角色三：Aggregrate（容器接口）->协议 作用：定义了存储元素的方法
• 角色四：ConcreteAggregrate（具体容器） 作用：实现了存储元素的方法

下面用到了泛型的概念，泛型其实就是为了方便支付多种类型的存储

所以我们去定义迭代器接口协议IteratorProtocol

import Foundation

protocol IteratorProtocol
{
    //由于我们不知道下一个元素的类型，所以我们这里声明为ItemType
    //associatedtype 就是拿来声明Swift的泛型关键字
    associatedtype ItemType

    //下一个元素
    func next() -> ItemType?

    //判断是否有元素
    func hasNext() -> Bool
}

然后我们再去定义一个迭代器的基本实现类AnyIterator可以把一些基本的操作写在里面，防止每个子类都要去写

import Cocoa

//这里定义一个基本的实现了IteratorProtocol协议的实现类，在这里面去做一些基本的操作
class AnyIterator<T>:IteratorProtocol
{


    //记录当前遍历的位置
    var index:Int = 0

    var array:Array<T>

    init(array:Array<T>) {
        self.array = array
    }
    //实现协议的方法
    func next() -> T? {
        return nil
    }

    func hasNext() -> Bool {
        return false
    }
}

具体的实现类ConcreteIteraror，实现了遍历具体元素方法

import Cocoa

//什么是泛型？定义的时候不需要指定类型，使用的时候指定类型
class ConcreteIterator<T>: AnyIterator<T> {

    override func next() -> T? {
        if self.hasNext() {
            let result = self.array[index]
            index += 1
            return result
        }
        return nil
    }
    //判断是否还有下一个元素
    override func hasNext() -> Bool {
        return index != self.array.count
    }

}

再下面就是AggregrateProtocol协议的定义，用于添加元素、删除元素、迭代器的获取，定义了存储元素的方法

import Foundation

//容器：保存数据类型->泛型
protocol AggregrateProtocol
{
    associatedtype DataType

    //添加元素
    func add(data:DataType)
    //删除元素
    func remove(index:Int) ->DataType
    //迭代器
    func iterator() -> AnyIterator<DataType>
}

具体的实现类ConcreteAggregrate，实现了存储元素的方法

import Cocoa

class ConcreteAggregrate<D>:AggregrateProtocol
{
    //给DataType定义一个别名
    typealias DataType = D

    private var array = Array<D>()

    func add(data: D) {
        //插入数据
        self.array.append(data)
    }

    func remove(index: Int) -> D {
        return self.array.remove(at: index)
    }

    func iterator() -> AnyIterator<D> {
        //初始化(将数组传递到我们的迭代器中，由我们的迭代器来遍历元素)
        return ConcreteIteraror<D>(array: self.array)
    }

}

去创建迭代器，然后进行存储元素和取元素

let a = "人"
let b = "世界观"
let c = "你"

let aggregrate = ConcreteAggregrate<String>()
aggregrate.add(data: a)
aggregrate.add(data: b)
aggregrate.add(data: c)

let iterator = aggregrate.iterator()
while iterator.hasNext(){
    let result = iterator.next()
    print("结果:\(result ?? "")")
}