MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Objective-C 中的迭代器模式理解与实践

2024-10-146.3k 阅读

迭代器模式基础概念

迭代器模式定义

迭代器模式（Iterator Pattern）是一种行为设计模式，它提供一种方法顺序访问一个聚合对象中各个元素，而又不需要暴露该对象的内部表示。简单来说，迭代器模式让我们能够在不了解集合内部结构的情况下遍历集合中的元素。

在 Objective - C 的编程环境中，很多时候我们会处理各种集合，如数组（NSArray）、字典（NSDictionary）等。虽然这些集合类本身已经提供了一些遍历方式，但迭代器模式提供了一种更通用、更灵活的遍历机制，尤其在处理自定义的复杂集合结构时，其优势更为明显。

迭代器模式的角色

  1. 迭代器（Iterator）：定义访问和遍历元素的接口。在 Objective - C 中，这通常会以一个协议（protocol）的形式出现，它声明了诸如获取下一个元素、判断是否还有更多元素等方法。
  2. 具体迭代器（Concrete Iterator）：实现迭代器接口。它跟踪遍历的当前位置，并提供实际的遍历逻辑。例如，对于一个自定义的链表集合，具体迭代器会维护一个指向链表当前节点的指针，并通过移动该指针来实现元素的遍历。
  3. 聚合（Aggregate）：定义创建迭代器对象的接口。在 Objective - C 中，这可能是一个包含特定数据结构的类，并声明一个创建迭代器的方法。
  4. 具体聚合（Concrete Aggregate）：实现创建迭代器的接口，返回一个具体迭代器的实例。它内部包含实际要遍历的数据集合。

Objective - C 中迭代器模式的实现原理

协议定义迭代器接口

在 Objective - C 中，我们首先通过协议来定义迭代器接口。以下是一个简单的迭代器协议示例：

@protocol IteratorProtocol <NSObject>
- (id)nextObject;
- (BOOL)hasNext;
@end

在这个协议中，nextObject 方法用于获取集合中的下一个元素，hasNext 方法用于判断集合中是否还有更多的元素可供遍历。

具体迭代器类实现

假设我们有一个自定义的简单数组集合类 MyArray，我们来为它创建一个具体的迭代器类 MyArrayIterator。

@interface MyArrayIterator : NSObject <IteratorProtocol> {
    NSMutableArray *_array;
    NSUInteger _currentIndex;
}
- (instancetype)initWithArray:(NSMutableArray *)array;
@end

@implementation MyArrayIterator
- (instancetype)initWithArray:(NSMutableArray *)array {
    self = [super init];
    if (self) {
        _array = array;
        _currentIndex = 0;
    }
    return self;
}

- (id)nextObject {
    if ([self hasNext]) {
        id object = _array[_currentIndex];
        _currentIndex++;
        return object;
    }
    return nil;
}

- (BOOL)hasNext {
    return _currentIndex < _array.count;
}
@end

在 MyArrayIterator 类中，我们在初始化方法中接收一个 NSMutableArray 对象，并使用 _currentIndex 来跟踪当前遍历的位置。nextObject 方法返回当前位置的元素并将索引递增，hasNext 方法则通过比较当前索引和数组的元素个数来判断是否还有下一个元素。

聚合类与具体聚合类

接下来定义聚合类的协议以及具体聚合类 MyArray。

@protocol AggregateProtocol <NSObject>
- (id<IteratorProtocol>)createIterator;
@end

@interface MyArray : NSObject <AggregateProtocol> {
    NSMutableArray *_data;
}
- (instancetype)initWithData:(NSMutableArray *)data;
@end

@implementation MyArray
- (instancetype)initWithData:(NSMutableArray *)data {
    self = [super init];
    if (self) {
        _data = data;
    }
    return self;
}

- (id<IteratorProtocol>)createIterator {
    return [[MyArrayIterator alloc] initWithArray:_data];
}
@end

在 MyArray 类中，我们实现了 AggregateProtocol 协议中的 createIterator 方法，该方法返回一个 MyArrayIterator 实例，从而提供了获取迭代器的方式。

使用迭代器模式遍历集合

基本遍历操作

现在我们可以使用上述定义的类来进行集合的遍历。

NSMutableArray *dataArray = [NSMutableArray arrayWithObjects:@"Apple", @"Banana", @"Cherry", nil];
MyArray *myArray = [[MyArray alloc] initWithData:dataArray];
id<IteratorProtocol> iterator = [myArray createIterator];
while ([iterator hasNext]) {
    NSString *fruit = [iterator nextObject];
    NSLog(@"%@", fruit);
}

在这段代码中，我们首先创建了一个包含水果名称的 NSMutableArray，然后用它初始化 MyArray 对象。接着获取 MyArray 的迭代器，并通过 while 循环使用迭代器的 hasNext 和 nextObject 方法来遍历集合中的元素并打印。

复杂集合结构的遍历

假设我们有一个自定义的树形结构，每个节点可以有多个子节点。我们可以使用迭代器模式来遍历这个树形结构。

@interface TreeNode : NSObject {
    NSString *_value;
    NSMutableArray *_children;
}
- (instancetype)initWithValue:(NSString *)value;
- (void)addChild:(TreeNode *)child;
@property (nonatomic, readonly) NSString *value;
@property (nonatomic, readonly) NSMutableArray *children;
@end

@implementation TreeNode
- (instancetype)initWithValue:(NSString *)value {
    self = [super init];
    if (self) {
        _value = value;
        _children = [NSMutableArray array];
    }
    return self;
}

- (void)addChild:(TreeNode *)child {
    [_children addObject:child];
}
@end

@protocol TreeIteratorProtocol <NSObject>
- (TreeNode *)nextNode;
- (BOOL)hasNext;
@end

@interface TreeIterator : NSObject <TreeIteratorProtocol> {
    NSMutableArray *_stack;
}
- (instancetype)initWithRoot:(TreeNode *)root;
@end

@implementation TreeIterator
- (instancetype)initWithRoot:(TreeNode *)root {
    self = [super init];
    if (self) {
        _stack = [NSMutableArray arrayWithObject:root];
    }
    return self;
}

- (TreeNode *)nextNode {
    if ([self hasNext]) {
        TreeNode *node = _stack.lastObject;
        [_stack removeLastObject];
        NSArray *reversedChildren = [node.children reverseObjectEnumerator].allObjects;
        [_stack addObjectsFromArray:reversedChildren];
        return node;
    }
    return nil;
}

- (BOOL)hasNext {
    return _stack.count > 0;
}
@end

@interface Tree : NSObject <AggregateProtocol> {
    TreeNode *_root;
}
- (instancetype)initWithRootValue:(NSString *)rootValue;
@end

@implementation Tree
- (instancetype)initWithRootValue:(NSString *)rootValue {
    self = [super init];
    if (self) {
        _root = [[TreeNode alloc] initWithValue:rootValue];
    }
    return self;
}

- (id<IteratorProtocol>)createIterator {
    return [[TreeIterator alloc] initWithRoot:_root];
}
@end

在这个树形结构的实现中，TreeNode 类表示树的节点，每个节点可以有多个子节点。TreeIterator 类使用栈来实现深度优先遍历。Tree 类作为具体聚合类，实现了创建 TreeIterator 的方法。

遍历树形结构

我们可以这样使用树形结构及其迭代器：

Tree *tree = [[Tree alloc] initWithRootValue:@"Root"];
TreeNode *node1 = [[TreeNode alloc] initWithValue:@"Node 1"];
TreeNode *node2 = [[TreeNode alloc] initWithValue:@"Node 2"];
TreeNode *node3 = [[TreeNode alloc] initWithValue:@"Node 3"];
[node1 addChild:node2];
[node1 addChild:node3];
[tree->_root addChild:node1];

id<IteratorProtocol> treeIterator = [tree createIterator];
while ([treeIterator hasNext]) {
    TreeNode *node = [treeIterator nextNode];
    NSLog(@"%@", node.value);
}

这段代码创建了一个简单的树形结构，并使用迭代器进行深度优先遍历，打印出每个节点的值。

与其他设计模式的关系

与组合模式的结合

迭代器模式经常与组合模式一起使用。组合模式允许我们将对象组合成树形结构以表示“部分 - 整体”的层次结构，而迭代器模式则可以用于遍历这种树形结构。例如，在上述树形结构的例子中，我们使用迭代器模式来遍历通过组合模式构建的树形结构。组合模式关注的是对象的组合和层次结构，而迭代器模式关注的是如何遍历这些对象。

与工厂模式的关联

工厂模式可以用于创建迭代器对象。在我们之前的例子中，MyArray 和 Tree 类通过 createIterator 方法创建具体的迭代器实例，这其实可以看作是一种简单的工厂方法。更复杂的场景下，可以使用抽象工厂模式来创建不同类型集合的迭代器，使得创建迭代器的过程更加灵活和可扩展。

迭代器模式在 iOS 框架中的应用

NSArray 和 NSEnumerator

在 iOS 框架中，NSArray 类与 NSEnumerator 就体现了迭代器模式的思想。NSArray 类似聚合类，而 NSEnumerator 及其子类（如 NSIndexEnumerator 和 NSEnumerator 本身）类似迭代器。

NSArray *numbers = @[@1, @2, @3, @4];
NSEnumerator *enumerator = [numbers objectEnumerator];
NSNumber *number;
while (number = [enumerator nextObject]) {
    NSLog(@"%@", number);
}

这里 objectEnumerator 方法类似于 createIterator 方法，返回一个 NSEnumerator 实例，通过 nextObject 方法进行元素的遍历。

NSDictionary 和 NSEnumerator

同样，NSDictionary 也可以使用 NSEnumerator 来遍历其键值对。

NSDictionary *person = @{@"name": @"John", @"age": @30};
NSEnumerator *keyEnumerator = [person keyEnumerator];
id key;
while (key = [keyEnumerator nextObject]) {
    id value = person[key];
    NSLog(@"%@: %@", key, value);
}

通过 keyEnumerator 或 objectEnumerator 方法，NSDictionary 提供了获取迭代器的方式，从而遍历其内容。

迭代器模式的优势与局限性

优势

  1. 分离集合与遍历逻辑：迭代器模式将集合对象的遍历逻辑从集合类中分离出来，使得集合类只需要关注数据的存储和管理，而迭代器类专注于遍历。这样可以提高代码的可维护性和可扩展性。例如，当我们需要改变遍历方式时，只需要修改迭代器类的代码，而不需要修改集合类。
  2. 提供统一遍历接口：无论集合的内部结构多么复杂，迭代器都提供了统一的遍历接口。这使得客户端代码可以以相同的方式遍历不同类型的集合，提高了代码的复用性。比如，我们可以使用相同的迭代器遍历数组、链表或者树形结构。
  3. 支持多种遍历方式：我们可以为同一个集合创建多个不同的迭代器，每个迭代器可以实现不同的遍历策略。例如，对于一个树形结构，我们可以创建深度优先遍历的迭代器，也可以创建广度优先遍历的迭代器。

局限性

  1. 增加类的数量：使用迭代器模式会增加系统中类的数量，因为需要定义迭代器接口、具体迭代器类、聚合接口和具体聚合类。这可能会使系统的设计变得更加复杂，尤其是在简单场景下，可能会显得过于繁琐。
  2. 性能开销：迭代器对象需要维护一些状态信息，如当前遍历位置等，这会增加一定的内存开销。在处理大量数据时，这种开销可能会变得比较明显。此外，方法调用也会带来一定的性能损失，相比于直接在集合类中实现遍历方法，使用迭代器模式可能会稍微慢一些。

总结迭代器模式的适用场景

  1. 需要顺序访问聚合对象中的元素：当我们需要按顺序逐个访问集合中的元素，并且不希望暴露集合的内部结构时，迭代器模式是一个很好的选择。例如，在处理自定义的数据结构，如链表、树形结构等时，迭代器模式可以提供简洁的遍历方式。
  2. 支持多种遍历方式：如果希望为同一个集合提供多种不同的遍历方式，如深度优先遍历和广度优先遍历，迭代器模式可以通过创建不同的具体迭代器类来实现。
  3. 遍历逻辑复杂：当集合的遍历逻辑比较复杂，不适合直接在集合类中实现时，将遍历逻辑封装到迭代器类中可以使代码结构更加清晰。例如，在遍历一个具有复杂嵌套结构的集合时，迭代器模式可以将复杂的遍历逻辑进行隔离。

通过以上对迭代器模式在 Objective - C 中的深入理解与实践，我们可以看到迭代器模式在处理集合遍历方面提供了强大而灵活的解决方案，尽管它存在一些局限性，但在合适的场景下使用可以显著提高代码的质量和可维护性。在实际的 iOS 开发中，结合 iOS 框架中已有的类似迭代器的机制，合理运用迭代器模式可以让我们的代码更加优雅和高效。