程序员必知！迭代器模式的实战应用与案例分析

程序员必知！迭代器模式的实战应用与案例分析 - 程序员古德

迭代器模式提供了遍历聚合对象中各元素的方法，通过它无需了解其底层结构，例如，在电商平台商品列表中统计销售额时，可通过迭代器简化遍历过程，加总每个商品销售额，此模式使代码更简洁、易维护，且适用于不同类型的聚合对象，实现轻松扩展。

定义

程序员必知！迭代器模式的实战应用与案例分析 - 程序员古德

迭代器模式提供了一种遍历一个聚合对象中各个元素的方法，而不需要知道该对象的底层表示方式，它的主要目的是提供一个统一的、简洁的方式来遍历一个聚合对象的所有元素，而不需要关心该聚合对象的内部表示方式。

举一个业务中形象的例子来说明迭代器模式：假设有一个电商平台的商品列表，这个商品列表由多个商品组成，现在想要统计所有商品的销售额，可以使用迭代器模式来遍历所有商品并计算总销售额，具体来说，可以定义一个商品列表的聚合对象，然后定义一个迭代器，通过迭代器来遍历所有的商品对象，并对每个商品对象执行加总操作，最终得到所有商品的销售额，使用迭代器模式可以使得代码更加简洁、易于维护，并且可以轻松地扩展到其他类型的聚合对象。

代码案例

程序员必知！迭代器模式的实战应用与案例分析 - 程序员古德反例

下面是一个未使用迭代器模式的反例代码，在未使用迭代器模式的情况下，要遍历一个聚合对象（比如一个列表或集合）并对其进行操作，通常可能会直接在client代码中处理聚合对象的内部表示，这样做会导致client代码与聚合对象的内部结构紧密耦合，违反了设计模式的封装原则，如下代码：

import java.util.ArrayList;

import java.util.List;

// 产品类

class Product {

private String name;

private double price;

public Product(String name, double price) {

this.name = name;

this.price = price;

}

public String getName() {

return name;

}

public double getPrice() {

return price;

}

@Override

public String toString() {

return "Product{" +

"name='" + name + '\'' +

", price=" + price +

'}';

}

}

// 产品目录类，未使用迭代器模式

class ProductCatalog {

// 内部使用ArrayList存储产品

private List products = new ArrayList();

// 直接暴露内部列表，违反封装原则

public List getProducts() {

return products;

}

public void addProduct(Product product) {

products.add(product);

}

}

// 客户端代码

public class Client {

public static void main(String[] args) {

ProductCatalog catalog = new ProductCatalog();

catalog.addProduct(new Product("Laptop", 999.99));

catalog.addProduct(new Product("Smartphone", 499.99));

catalog.addProduct(new Product("Tablet", 299.99));

// 客户端直接操作ProductCatalog的内部结构

for (Product product : catalog.getProducts()) {

System.out.println(product);

}

// 假设我们需要修改ProductCatalog的内部实现，比如使用LinkedList替代ArrayList

// 那么客户端代码也需要相应地进行修改，这违反了开闭原则

}

}

运行上面的代码会得到以下输出：

Product{name='Laptop', price=999.99}

Product{name='Smartphone', price=499.99}

Product{name='Tablet', price=299.99}

在这个例子中，ProductCatalog类直接暴露了它的内部列表products，client代码通过getProducts方法直接访问这个列表并进行遍历，这样做的问题是，如果ProductCatalog的内部实现发生变化（比如从ArrayList换成LinkedList），client代码也需要相应地进行修改，因为client代码已经与ProductCatalog的内部实现紧密耦合在一起了。

为了避免这种紧密耦合，应该使用迭代器模式来提供一个统一的遍历接口，从而隐藏聚合对象的内部表示，这样，即使聚合对象的内部实现发生变化，client代码也不需要修改，因为它只依赖于迭代器接口。

正例

下面是一个使用迭代器模式的正例代码，创建一个迭代器接口来定义遍历元素所需的方法，然后为聚合对象创建一个类来实现这个接口，这样做的好处是client代码可以只依赖于迭代器接口，而不是聚合对象的具体实现，从而实现了松耦合，如下代码：

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

// 产品类

class Product {

private String name;

private double price;

public Product(String name, double price) {

this.name = name;

this.price = price;

}

public String getName() {

return name;

}

public double getPrice() {

return price;

}

@Override

public String toString() {

return "Product{" +

"name='" + name + '\'' +

", price=" + price +

'}';

}

}

// 迭代器接口

interface Iterator {

boolean hasNext();

T next();

}

// 产品目录类，使用了迭代器模式

class ProductCatalog implements Iterable {

// 内部使用ArrayList存储产品

private List products = new ArrayList();

public void addProduct(Product product) {

products.add(product);

}

// 创建并返回产品迭代器

@Override

public Iterator iterator() {

return new ProductIterator(products);

}

// 私有内部类实现迭代器接口

private class ProductIterator implements Iterator {

private List productList;

private int position;

public ProductIterator(List productList) {

this.productList = productList;

}

@Override

public boolean hasNext() {

return position 

}

@Override

public Product next() {

if (hasNext()) {

return productList.get(position++);

} else {

return null; // 或者抛出异常

}

}

}

}

// 客户端代码

public class Client {

public static void main(String[] args) {

ProductCatalog catalog = new ProductCatalog();

catalog.addProduct(new Product("Laptop", 999.99));

catalog.addProduct(new Product("Smartphone", 499.99));

catalog.addProduct(new Product("Tablet", 299.99));

// 使用迭代器遍历产品目录

for (Product product : catalog) {

System.out.println(product);

}

// 客户端代码不依赖于ProductCatalog的内部实现，

// 如果内部实现发生变化，客户端代码不需要修改。

}

}

运行上面的代码会得到以下输出：

Product{name='Laptop', price=999.99}

Product{name='Smartphone', price=499.99}

Product{name='Tablet', price=299.99}

在这个例子中，ProductCatalog类实现了Iterable接口，并提供了一个iterator方法来创建并返回ProductIterator对象，ProductIterator是ProductCatalog的一个私有内部类，它实现了Iterator接口来遍历产品列表，client代码使用增强的for循环（它内部使用了迭代器）来遍历ProductCatalog中的产品，而不需要知道其内部是如何存储产品的。

这个实现遵循了迭代器模式，允许client代码以统一的方式遍历聚合对象，而不需要了解聚合对象的内部表示，使得client代码与聚合对象之间实现了松耦合，符合开闭原则。

核心总结

程序员必知！迭代器模式的实战应用与案例分析 - 程序员古德

迭代器模式是一种常用的设计模式，它使程序能够遍历聚合对象的元素而无需暴露其内部表示，它支持对聚合对象的多种遍历，简化了聚合类，符合单一职责原则，使client代码与聚合对象的具体实现解耦，增强了系统的可扩展性，当需要新增遍历方式时，只需增加新的迭代器类，不影响原有代码；迭代器模式会涉及到较多的类，可能会增加系统的复杂性和开发成本，同时，由于它将存储数据和遍历数据的职分离，可能在某些情况下导致额外的性能开销，在需要遍历复杂数据结构或支持多种遍历方式时，推荐使用迭代器模式，但要注意权衡系统复杂性和灵活性，避免过度设计，同时，可以考虑使用Java内置的迭代器接口和工具类来简化实现。