Java的设计模式——迭代器模式

设计模式被证明是解决特定问题/任务的解决方案。我们需要记住，设计模式是独立于编程语言的，用于解决常见的面向对象设计问题。换句话说，设计模式代表一个想法，而不是一个特定的实现。使用设计模式可以使您的代码更加灵活、可重用和可维护。

设计模式的类型： Java中有 3 种设计模式，下面以表格形式更清楚地描述。

行为设计模式
创意设计模式
结构设计模式

Behavioral	Creational	Structural
Iterator Pattern	Factory Pattern	Adapter Pattern
Interpreter Pattern	Abstract Factory Pattern	Bridge Pattern
Mediator Pattern	Singleton Pattern	Composite Pattern
Memento Pattern	Prototype Pattern	Decorator Pattern
Observer Pattern	Builder Pattern	Facade Pattern
State Pattern		Flyweight Pattern
Strategy Pattern		Proxy Pattern
Template Pattern
Visitor Pattern

行为 - 迭代器模式

在这里，我们将通过一个例子来讨论迭代器模式。

迭代器模式是一种很好的模式，可以在不暴露对象结构的情况下提供导航。
遍历一个容器。在Java和大多数当前的编程语言中，有集合的概念。 List、Maps、Sets 都是我们想要遍历的集合的例子。从历史上看，我们使用某种循环和索引到您的集合中来遍历它。
不暴露我们要导航的对象的底层结构。导航各种结构可能有不同的算法或方法来循环数据。
将数据与用于遍历它的算法分离

设计：迭代器模式

它是一种基于接口的设计模式。无论您要迭代哪个对象，都将提供一种方法来从中返回迭代器的实例。
以获取迭代器实例的方式遵循基于工厂的方法模式。
每个迭代器都以独立于另一个的方式开发。
迭代器也会快速失败。 Fail Fast 意味着迭代器不能在不抛出错误的情况下修改底层对象。

Collection 接口由 List 接口扩展。
List 接口包含一个工厂方法 iterator()。这个迭代器工厂方法返回一个迭代器接口的实例。
在列表及其实现的情况下，底层实例是 ListIterator。
ListIterator 是 Iterator 接口的实现，它了解如何迭代 Collection API 中的各种列表对象。它声明了组合中对象的接口。

迭代器存在一些缺陷，如下所示：

您无权访问任何类型的索引。如果您想获得某个位置的元素，那么不进行迭代就无法做到这一点。在集合和映射的情况下，没有一种方法可以在某个索引位置抓取元素
UniDirectional：它仅在转发方向上迭代对象。
尽管迭代器是遍历任何类型对象的最有效方法。但在某些情况下，它可能比使用索引并循环遍历它更慢。

例子：

Java

// Java Program to Implement Behavioral>Iterator Pattern
 
// importing required package to
// implement Behavioral>Iterator Pattern
package com.demo.application;
 
// Importing required libraries
// Here Iterator Interface to
// use it to iterate over the elements
import java.util.Iterator;
 
 
// Class 1
 
// Car Class Implementing Iterable Interface so
// that we can implement the iterator method and
// add our own implementation
 
public class Car implements Iterable {
  private String[] cars;
  private int index;
 
  // Default Constructor
  public Car() {
    cars = new String[10];
    index = 0;
  }
 
  // Method 1
  // Adding method to add Cars
  public void addCar(String car) {
    if (index == cars.length) {
      String[] largerCars = new String[cars.length + 5];
      System.arraycopy(cars, 0, largerCars, 0, cars.length);
      cars = largerCars;
      largerCars = null;
    }
    cars[index] = car;
    index++;
  }
 
  // Method 2
  // Implementing the iterator method and
  // adding your own implementation
  @Override
  public Iterator iterator() {
    Iterator it = new Iterator() {
 
      private int currentIndex = 0;
 
      // Method 3
      // Finding whether during iteration if
      // there is next element or not
      @Override
      public boolean hasNext() {
        return currentIndex < cars.length && cars[currentIndex] != null;
      }
 
      // Method 4
      // Going to grab each car element by one by one
      // according to the index
      @Override
      public String next() {
        return cars[currentIndex++];
      }
 
      // Method 5
      @Override
      public void remove() {
        throw new UnsupportedOperationException();
      }
    };
 
    return it;
  }
 
  // Method 6
  // Main driver method
  public static void main(String[] args) {
 
    // Instantiating Car object
    Car cars = new Car();
 
    // Adding cars to the Array
    cars.addCar("Dodge");
    cars.addCar("Ferrari");
    cars.addCar("Sedan");
 
    // Creating an Iterator and pointing the cursor
    // to the index just before the first element in cars
    Iterator carIterator = cars.iterator();
 
    // Checking whether the next element is available or not
    while (carIterator.hasNext()) {
      System.out.println(carIterator.next());
    }
  }
}

结论：

迭代器是遍历对象的有效方式。
对客户端隐藏算法，以便您的客户端的简单性包含在您正在为其创建迭代器的容器中的算法中
帮助我们简化该客户端。
帮助我们利用 for each 语法，这绝对简化了在 for each 循环中对该对象的迭代。