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

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

定义

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

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

代码案例

反例

下面是一个未使用迭代器模式的反例代码，在未使用迭代器模式的情况下，要遍历一个聚合对象（比如一个列表或集合）并对其进行操作，通常可能会直接在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<Product> products = new ArrayList<>();  
  
    // 直接暴露内部列表，违反封装原则  
    public List<Product> 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<T> {  
    boolean hasNext();  
    T next();  
}  
  
// 产品目录类，使用了迭代器模式  
class ProductCatalog implements Iterable<Product> {  
    // 内部使用ArrayList存储产品  
    private List<Product> products = new ArrayList<>();  
  
    public void addProduct(Product product) {  
        products.add(product);  
    }  
  
    // 创建并返回产品迭代器  
    @Override  
    public Iterator<Product> iterator() {  
        return new ProductIterator(products);  
    }  
  
    // 私有内部类实现迭代器接口  
    private class ProductIterator implements Iterator<Product> {  
        private List<Product> productList;  
        private int position;  
  
        public ProductIterator(List<Product> productList) {  
            this.productList = productList;  
        }  
  
        @Override  
        public boolean hasNext() {  
            return position < productList.size();  
        }  
  
        @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内置的迭代器接口和工具类来简化实现。