前言

本节给大家讲一下设计模式中的迭代器模式,并结合实际业务场景给大家讲解如何使用~

案例代码主要以Java语言为主, 好了, 废话不多说直接开整~

一、迭代器模式

迭代器模式是一种设计模式，它允许客户端逐个访问一个聚合对象中的元素，而不必了解该对象的内部结构。它将聚合对象和访问元素的方式分离开来，使得聚合对象的内部结构可以自由地改变，而不会影响客户端的访问方式。该模式提供了一种标准的方法来遍历一个聚合对象，而不需要了解该聚合对象的实现细节。

在迭代器模式中，有两个主要的角色：聚合对象和迭代器。聚合对象是一个包含一组元素的对象，它提供了一个创建迭代器的方法，该迭代器可以按照一定的顺序逐个访问该聚合对象中的元素。迭代器是一个对象，它提供了访问聚合对象中元素的方法，可以通过这些方法依次访问聚合对象中的元素。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorPatternDemo {
   public static void main(String[] args) {
      List<String> names = new ArrayList<String>();
      names.add("John");
      names.add("Mike");
      names.add("Sarah");
      
      Iterator<String> iter = names.iterator();
      while(iter.hasNext()) {
         String name = iter.next();
         System.out.println("Name: " + name);
      }
   }
}

在上面的示例中，我们创建了一个List对象，并向其中添加了一些字符串元素。然后，我们使用iterator()方法获取一个迭代器对象，并使用while循环遍历该列表，直到所有元素都被访问完毕。在循环中，我们使用hasNext()方法检查是否还有下一个元素，如果有，就使用next()方法获取下一个元素，并将其打印出来。

这个示例展示了如何使用Java集合框架提供的内置迭代器来遍历一个列表。在实际的应用中，我们也可以自己实现一个迭代器类来遍历一个自定义的聚合对象。无论是使用内置迭代器还是自定义迭代器，迭代器模式都可以帮助我们实现更加灵活、可扩展的遍历操作。

二、最佳实践

假设我们有一个电商平台的订单系统，其中有一个订单列表，我们可以使用迭代器模式来遍历这个订单列表。

假设我们有一个名为 Order 的类，它表示一个订单，包含订单号、订单时间、订单金额等属性：

public class Order {
    private String orderNumber;
    private String orderTime;
    private double orderAmount;

    public Order(String orderNumber, String orderTime, double orderAmount) {
        this.orderNumber = orderNumber;
        this.orderTime = orderTime;
        this.orderAmount = orderAmount;
    }

    public String getOrderNumber() {
        return orderNumber;
    }

    public String getOrderTime() {
        return orderTime;
    }

    public double getOrderAmount() {
        return orderAmount;
    }
}

接下来，我们定义一个名为 OrderList 的类，表示订单列表。在这个类中，我们使用一个名为 orders 的私有成员变量来存储订单列表，然后实现了 addOrder()、iterator() 和 hasNext() 方法，其中 iterator() 方法返回了一个 OrderIterator 对象，它实现了迭代器接口。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class OrderList implements Iterable<Order> {
    private List<Order> orders;

    public OrderList() {
        this.orders = new ArrayList<>();
    }

    public void addOrder(Order order) {
        orders.add(order);
    }

    @Override
    public Iterator<Order> iterator() {
        return new OrderIterator();
    }

    private class OrderIterator implements Iterator<Order> {
        private int index;

        @Override
        public boolean hasNext() {
            return index < orders.size();
        }

        @Override
        public Order next() {
            if (hasNext()) {
                Order order = orders.get(index);
                index++;
                return order;
            } else {
                throw new IndexOutOfBoundsException("No more orders to iterate");
            }
        }
    }
}

在上面的代码中，我们使用了 Java 内置的Iterator接口来实现迭代器。在 OrderList 类中，我们重写了 iterator() 方法，返回了一个 OrderIterator 对象。在OrderIterator类中，我们实现了hasNext()和 next() 方法，其中 hasNext() 方法用于检查是否还有下一个订单，next() 方法用于返回当前的订单，并将迭代器指针向后移动一位。

最后，我们可以使用迭代器来遍历订单列表：

public class Client {
    public static void main(String[] args) throws Exception {
        OrderList orderList = new OrderList();
        orderList.addOrder(new Order("20230001", "2023-04-21 10:00:00", 100.00));
        orderList.addOrder(new Order("20230002", "2023-04-22 11:00:00", 200.00));
        orderList.addOrder(new Order("20230003", "2023-04-23 12:00:00", 300.00));

        Iterator<Order> iterator = orderList.iterator();
        while (iterator.hasNext()) {
            Order order = iterator.next();
            System.out.println(order.getOrderNumber() + " " + order.getOrderTime() + " " + order.getOrderAmount());
        }
    }
}

输出:

20230001 2023-04-21 10:00:00 100.0
20230002 2023-04-22 11:00:00 200.0
20230003 2023-04-23 12:00:00 300.0

总结

设计模式其实并不难，大家在学习的时候一定要在理解的基础上去写代码，不要去背代码。