Patrones de diseño en Java – Patrón iterador

Un patrón de diseño es una solución comprobada para resolver el problema/tarea específico. Debemos tener en cuenta que los patrones de diseño son independientes del lenguaje de programación para resolver los problemas comunes de diseño orientado a objetos. En otras palabras, un patrón de diseño representa una idea, no una implementación particular. Usando patrones de diseño, puede hacer que su código sea más flexible, reutilizable y mantenible.

Tipos de patrones de diseño: hay 3 tipos de patrones de diseño en Java que se muestran más claramente en un formato tabular a continuación.

1. Patrón de diseño de comportamiento
2. Patrón de diseño creacional
3. Patrón de diseño estructural

Comportamiento: patrón de iterador

Aquí discutiremos Iterator Pattern con un ejemplo.

• El patrón de iterador es un gran patrón para proporcionar navegación sin exponer la estructura de un objeto.
• Atraviesa un contenedor. En Java y en la mayoría de los lenguajes de programación actuales, existe la noción de colección. List, Maps, Sets son todos ejemplos de una colección que nos gustaría recorrer. Históricamente, usamos un bucle de algún tipo e indexamos su colección para recorrerlo.
• No expone la estructura subyacente del objeto que queremos navegar. Navegar por varias estructuras puede tener diferentes algoritmos o enfoques para recorrer los datos.
• Desacopla los datos del algoritmo utilizado para atravesarlos.

Diseño: patrón iterador

• Es un patrón de diseño basado en la interfaz. Cualquiera que sea el objeto sobre el que desee iterar, proporcionará un método para devolver una instancia de un iterador.
• Sigue un patrón de método basado en fábrica en la forma en que obtiene una instancia del iterador.
• Cada iterador se desarrolla de tal manera que es independiente de otro.
• Los iteradores también fallan rápido. Fail Fast significa que los iteradores no pueden modificar el objeto subyacente sin que se produzca un error.

• La interfaz de colección se amplía con la interfaz de lista.
• La interfaz de lista contiene un iterador de método de fábrica(). Este método de fábrica de iteradores devuelve una instancia de la interfaz de iterador.
• En el caso de la lista y sus implementaciones, las instancias subyacentes son ListIterator.
• ListIterator es una implementación de la interfaz Iterator que comprende cómo iterar sobre los diversos objetos de lista en la API de colección. Declara la interfaz para los objetos en la composición.

Hay algunas trampas del iterador que son las siguientes:

• No tienes acceso a un índice de ningún tipo. Sin embargo, si desea obtener un elemento de una determinada posición, no hay forma de hacerlo sin solo iterar. En el caso de conjuntos y mapas, no existe un método para tomar un elemento en una determinada posición de índice
• Unidireccional: itera objetos solo en la dirección de envío.
• Aunque el iterador es la forma más eficiente de recorrer objetos de cualquier tipo. Pero en algunos casos, puede ser más lento que usar un índice y recorrerlo.

Ejemplo:

// 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<String> {
  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<String> iterator() {
    Iterator<String> it = new Iterator<String>() {
 
      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<String> carIterator = cars.iterator();
 
    // Checking whether the next element is available or not
    while (carIterator.hasNext()) {
      System.out.println(carIterator.next());
    }
  }
}

Conclusión:

• Un iterador es una forma eficiente de atravesar un objeto.
• Oculta el algoritmo del cliente, por lo que la simplicidad para su cliente está contenida dentro del algoritmo que ha cubierto en el contenedor para el que está creando un iterador.
• Nos ayuda a simplificar ese cliente.
• Nos ayuda a aprovechar la sintaxis for each que definitivamente simplifica la iteración sobre ese objeto en un bucle for each.