【设计模式】用Java实现迭代器模式

一.迭代器模式介绍与使用场景

迭代器模式（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() 方法来遍历聚合对象的电影。