一.迭代器模式介绍与使用场景
迭代器模式（Iterator Pattern）是一种行为设计模式，它提供了一种顺序访问聚合对象中各个元素的方法，而无需暴露聚合对象的内部表示。
迭代器模式的核心是迭代器接口（Iterator），该接口定义了访问和遍历聚合对象元素的方法。具体的聚合对象实现了创建相应迭代器的方法，并通过迭代器来访问自身的元素。
应用场景：
1.当需要遍历一个聚合对象，并且不希望暴露聚合对象的内部表示时，可以使用迭代器模式。迭代器模式将遍历操作封装在迭代器中，客户端可以通过迭代器访问和遍历聚合对象的元素，而无需了解聚合对象的具体实现。
2.当需要对不同类型的聚合对象提供一致的遍历接口时，可以使用迭代器模式。通过定义一个通用的迭代器接口，不同类型的聚合对象可以提供相应的迭代器实现，使得客户端可以以统一的方式进行遍历。
3.当需要支持对聚合对象的多种遍历方式时，可以使用迭代器模式。通过定义不同的迭代器实现，每个迭代器可以实现一种特定的遍历方式，客户端可以根据需要选择合适的迭代器进行遍历。
4.当需要在遍历过程中实现对聚合对象的元素进行筛选、过滤或者其他操作时，可以使用迭代器模式。通过在迭代器中添加相应的方法，可以实现对聚合对象元素的操作，而无需修改聚合对象本身。
5.当希望对聚合对象进行遍历时，但又不希望在遍历过程中暴露聚合对象的内部结构时，可以使用迭代器模式。迭代器模式将遍历操作封装在迭代器中，客户端只能通过迭代器来访问和遍历聚合对象的元素，而无法直接访问聚合对象的内部结构。
需要注意的是，迭代器模式适用于需要遍历和访问聚合对象的情况。如果聚合对象很简单，直接通过索引或者方法调用就能访问其中的元素，可能不需要使用迭代器模式。此外，对于不需要频繁遍历的情况，也可以考虑其他简单的遍历方式。
二.迭代器模式实现
首先，我们定义迭代器接口 Iterator：
public interface Iterator<T> { boolean hasNext(); T next(); }
然后，我们创建聚合对象接口 Aggregate，定义了获取迭代器的方法：
public interface Aggregate { Iterator<String> createIterator(); }
接下来，我们创建具体聚合对象 ConcreteAggregate，实现了聚合对象接口，并实现了创建相应迭代器的方法：
import java.util.ArrayList; import java.util.List; public class ConcreteAggregate implements Aggregate { private List<String> items; public ConcreteAggregate() { items = new ArrayList<>(); } public void addItem(String item) { items.add(item); } public Iterator<String> createIterator() { return new ConcreteIterator(items); } }
然后，我们定义具体迭代器类 ConcreteIterator，实现了迭代器接口，负责实现对聚合对象的遍历操作：
public class ConcreteIterator implements Iterator<String> { private List<String> items; private int position; public ConcreteIterator(List<String> items) { this.items = items; position = 0; } public boolean hasNext() { return position < items.size(); } public String next() { if (hasNext()) { String item = items.get(position); position++; return item; } return null; } }
最后，我们可以在客户端中使用迭代器模式：
public class Client { public static void main(String[] args) { ConcreteAggregate aggregate = new ConcreteAggregate(); aggregate.addItem("Item 1"); aggregate.addItem("Item 2"); aggregate.addItem("Item 3"); Iterator<String> iterator = aggregate.createIterator(); while (iterator.hasNext()) { String item = iterator.next(); System.out.println(item); } } }
在上面的示例中，我们创建了一个具体聚合对象 aggregate，并向其添加了若干项。然后，通过调用聚合对象的 createIterator() 方法来获取相应的迭代器对象 iterator。最后，通过迭代器的 hasNext() 和 next() 方法来遍历聚合对象的元素。
下面再举一个实际场景下的应用例子
假设我们正在开发一个电影院管理系统，我们需要实现一个影片库存类 MovieList，该类维护了一组电影。我们希望能够通过迭代器来遍历影片库存中的电影。
首先，我们定义迭代器接口 Iterator：
public interface Iterator<T> { boolean hasNext(); T next(); }
然后，我们创建具体的聚合类 MovieList，实现了聚合接口，并实现了创建迭代器的方法：
import java.util.ArrayList; import java.util.List; public class MovieList implements Aggregate { private List<Movie> movies; public MovieList() { movies = new ArrayList<>(); } public void addMovie(Movie movie) { movies.add(movie); } public Iterator<Movie> createIterator() { return new MovieIterator(movies); } }
接下来，我们定义具体的迭代器类 MovieIterator，实现了迭代器接口，负责遍历聚合对象的元素：
import java.util.List; public class MovieIterator implements Iterator<Movie> { private List<Movie> movies; private int position; public MovieIterator(List<Movie> movies) { this.movies = movies; position = 0; } public boolean hasNext() { return position < movies.size(); } public Movie next() { if (hasNext()) { Movie movie = movies.get(position); position++; return movie; } return null; } }
接着，我们定义电影类 Movie，用于表示影片的信息：
public class Movie { private String title; public Movie(String title) { this.title = title; } public String getTitle() { return title; } }
最后，我们可以在客户端中使用迭代器模式：
public class Client { public static void main(String[] args) { MovieList movieList = new MovieList(); movieList.addMovie(new Movie("Movie 1")); movieList.addMovie(new Movie("Movie 2")); movieList.addMovie(new Movie("Movie 3")); Iterator<Movie> iterator = movieList.createIterator(); while (iterator.hasNext()) { Movie movie = iterator.next(); System.out.println(movie.getTitle()); } } }
在上面的示例中，我们创建了一个具体的聚合对象 movieList，并向其添加了若干电影。然后，通过调用聚合对象的 createIterator()方法来获取相应的迭代器对象 iterator。最后，通过迭代器的 hasNext()和 next() 方法来遍历聚合对象的电影。
