迭代器模式

迭代器模式-定义

提供一种方法，按照顺序访问一个容器对象中的各个元素，而又不需要暴露该容器的内部细节（内部表示）

迭代器模式-场景

遍历容器对象,例如：数据库框架 查询数据->返回数据->封装为对象（自定义对象）->遍历（自定义迭代器变量数据库元素）

迭代器模式-角色划分

4个核心角色
角色一：Iterator（迭代器接口）->协议
作用：定义了访问遍历元素的方法（标准）

角色二：ConcreteIterator（具体迭代器）
作用：遍历具体元素方法实现

角色三：Aggregrate（容器接口）->协议
作用：定义了存储元素的方法

角色四：ConcreteAggregrate（具体容器）
作用：实现了存储元素的方法

注意：以后在框架设计或者项目开发中，你发现有遍历元素的场景，第一时间想到的就是迭代器模式.

案例

角色一：迭代器接口 OrderIteratorProtocol

protocol OrderIteratorProtocol {
    
    // 定义泛型，可以返回任意类型的数据
    associatedtype ObjType
    
    // 读取下一个元素 值
    func next() -> ObjType?
    
    //是否有下一个元素值 
    func hasNext() -> Bool
}

角色二：具体迭代器OrderAnyIteractor(封装处理数据)

class OrderAnyIteractor<T>: NSObject,OrderIteratorProtocol {
    //使用泛型
    typealias ObjType = T
    
    func next() -> T? {
        return nil
    }
    
    func hasNext() -> Bool {
        return false
    }
}

角色二： 具体迭代器 继承自上面那个OrderCorrectIterator

class OrderCorrectIterator<TypeObj>: OrderAnyIteractor<TypeObj> {

  private var array:Array<TypeObj>
  private var index:Int = 0
  
  init(array:Array<TypeObj>) {
      self.array = array;
  }
  
 
  override func next() -> TypeObj? {
       // 先判断是否有数据   有 就取出 然后返回
      if self.hasNext(){
          let result = self.array[index]
          index += 1
          return result
      } else {
          // 否则返回空  注意 给泛型定义可选值
          return nil
      }
  }
  
  // 判断是否有数据
  override func hasNext() -> Bool {
      return self.array.count != index
  }
}

角色三： 容器接口

protocol AggregrateProtocol {
    // 定义一个泛型 ，用来装载数据
    associatedtype ObjData
    // 添加数据
    func add(data:ObjData)
    // 移除数据
    func remove(index:Int) -> ObjData
    //迭代器 ，用来进行数据的操作
    func iterator() -> OrderCorrectIterator<ObjData>
}

角色四：具体的容器

class CorrectAggregrate<T>: NSObject ,AggregrateProtocol{
    
    typealias ObjData = T
    
    private var array:Array<T>
    
    init(array:Array<T>) {
        self.array = array
    }
    func add(data: T) {
        self.array.append(data)
    }
    
    func remove(index: Int) -> T {
        let data = self.array[index]
        self.array.remove(at: index)
        return data
    }
    
    func iterator() -> OrderCorrectIterator<T> {
        return OrderCorrectIterator(array: self.array)
    }
}

外部调用：

        let firstModel = OrderModel("张三","买了个表",1990)
        let secModel = OrderModel("李四","买了个衣服",2000)
        let thirdModel = OrderModel("王五","买了个裤子",2200)
        let fouthModel = OrderModel("李六","买了个裤子",2200)
        
        
        let correctAgg = CorrectAggregrate(array: Array<OrderModel>())
        correctAgg.add(data: firstModel)
        correctAgg.add(data: secModel)
        correctAgg.add(data: thirdModel)
        
        // 迭代器
        let iterator = correctAgg.iterator()
        
        let result =  correctAgg.remove(index: 1)
        print(result.name,result.message,result.price)
        
        correctAgg.add(data: fouthModel)
        while iterator.hasNext() {
            let result = iterator.next()
            print(String(describing:result?.name),String(describing:result?.message),String(describing:result?.price))
        }