Explication détaillée de l'utilisation des itérateurs en Java

Cet article présente principalement des informations pertinentes sur l'utilisation détaillée des itérateurs en java. J'espère que cet article pourra aider tout le monde. Les amis dans le besoin peuvent se référer à

L'utilisation des itérateurs en java. la méthode

Préface :

Le modèle d'itérateur encapsule une collection, principalement pour fournir aux utilisateurs un moyen de parcourir ses éléments internes. Le modèle d'itérateur présente deux avantages : ① Il offre aux utilisateurs un moyen de parcourir sans exposer ses détails d'implémentation internes. ② Il attribue la responsabilité du déplacement entre les éléments aux itérateurs au lieu des objets agrégés, réalisant l'intégration entre les utilisateurs et les objets agrégés. .

Le mode itérateur gère principalement un objet agrégé via l'interface Iterator. Lors de son utilisation, l'utilisateur n'a besoin que d'obtenir un objet de type Iterator pour terminer le parcours de l'objet agrégé. Les objets agrégés ici font généralement référence à des objets avec un ensemble de caractéristiques identiques ou similaires telles que ArrayList, LinkedList et l'implémentation sous-jacente est un tableau. Le parcours des objets agrégés via le mode itérateur est principalement effectué via les méthodes next() et hasNext() de l'interface Iterator. La méthode next() renverra ici la valeur de l'élément du point de parcours actuel et la méthode hasNext(). représente le point de parcours actuel. Il n'y a aucun élément après cela. Il existe également une méthode Remove() dans l'interface Iterator, qui supprimera l'élément au point de parcours actuel. Cette méthode n'a pas besoin d'être utilisée dans des circonstances normales.Cette méthode peut être appelée dans certains cas particuliers. Si le parcours de l'objet d'agrégation actuel ne prend pas en charge cette opération, une UnSupportedOperationException peut être levée dans cette méthode.

Ici, nous utilisons l'exemple suivant pour illustrer le modèle d'itérateur. Il existe actuellement deux ensembles de menus pour deux restaurants. Un ensemble de menus est implémenté à l'aide d'un tableau, tandis que l'autre ensemble de menus est implémenté à l'aide d'une ArrayList. Désormais, en raison de la fusion des deux restaurants, les deux ensembles de menus doivent être intégrés. Puisque les chefs des deux côtés se sont habitués à leurs méthodes respectives d'assemblage de menus, ils espèrent tous deux continuer à conserver leurs propres styles de menu. Cependant, pour les serveurs, lorsqu'ils fournissent des menus aux clients, ils doivent les traiter de deux manières différentes selon deux ensembles de menus, ce qui augmentera inévitablement la difficulté du travail des serveurs. De plus, si de nouveaux restaurants sont fusionnés ultérieurement, comme par exemple. Si le type de menu utilisé est HashMap, alors le serveur conservera cet ensemble de menus, ce qui n'est pas propice à l'expansion. Selon les besoins du serveur, ce dont il a besoin, c'est d'une liste de menus, si elle est orientée vers différentes catégories de menus, cela augmentera inévitablement la difficulté de son travail, et les méthodes proposées dans les différentes catégories de menus ne correspondent pas nécessairement à ce dont le serveur a besoin. Par conséquent, en fonction des besoins du serveur, une spécification de menu doit être formulée afin que le serveur puisse le parcourir de la même manière. Le modèle d'itérateur peut être utilisé ici. Le serveur n'a qu'à parcourir l'interface de l'itérateur, et le menu appartenant à chaque chef n'a besoin que d'implémenter l'itérateur, et ils peuvent toujours gérer leurs éléments de menu à leur manière. Cela permet de découpler les différents menus et serveurs. Vous trouverez ci-dessous le code spécifique pour résoudre ce problème à l'aide du modèle d'itérateur.

Interface de menu (contient principalement des méthodes de création d'itérateurs) :

public interface Menu<T> {
  Iterator<T> createIterator();
}

Éléments de menu :

<🎜 >

public class MenuItem {
  private String name;
  private String description;
  private boolean vegetarian;
  private double price;

  public MenuItem(String name, String description, boolean vegetarian, double price) {
    this.name = name;
    this.description = description;
    this.vegetarian = vegetarian;
    this.price = price;
  }

  public String getName() {
    return name;
  }

  public String getDescription() {
    return description;
  }

  public boolean isVegetarian() {
    return vegetarian;
  }

  public double getPrice() {
    return price;
  }
}

Classe de menu (comment les éléments de menu sont assemblés) :

public class DinerMenu implements Menu<MenuItem> {
  private static final int MAX_ITEMS = 6;
  private int numberOfItems = 0;
  private MenuItem[] menuItems;

  public DinerMenu() {
    menuItems = new MenuItem[MAX_ITEMS];
    addItem("Vegetarian BLT", "(Fakin&#39;) Bacon with lettuce & tomato on whole wheat", true, 2.99);
    addItem("BLT", "Bacon with lettuce & tomato on whole wheat", false, 2.99);
    addItem("Soup of the day", "Soup of the day, with a side of potato salad", false, 3.29);
    addItem("Hotdog", "A hot dog, with saurkraut, relish, onions, topped with cheese", false, 3.05);
  }

  public void addItem(String name, String description, boolean vegetarian, double price) {
    MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
    if (numberOfItems >= MAX_ITEMS) {
      System.out.println("Sorry, menu is full, Can&#39;t add item to menu");
    } else {
      menuItems[numberOfItems] = menuItem;
      numberOfItems++;
    }
  }

  @Deprecated
  public MenuItem[] getMenuItems() {
    return menuItems;
  }

  public Iterator<MenuItem> createIterator() {
    return new DinerMenuIterator(menuItems);
  }
}
public class PancakeHouseMenu implements Menu<MenuItem> {
  private ArrayList<MenuItem> menuItems;

  public PancakeHouseMenu() {
    menuItems = new ArrayList<>();
    addItem("K&B&#39;s Pancake Breakfast", "Pancakes with scrambled eggs, and toast", true, 2.99);
    addItem("Regular Pancake Breakfast", "Pancakes with fried eggs, sausage", false, 2.99);
    addItem("Blueberry Pancakes", "Pancakes made with fresh blueberries", true, 3.49);
    addItem("Waffles", "Waffles, with your choice of blueberries or strawberries", true, 3.49);
  }

  public void addItem(String name, String description, boolean vegetarian, double price) {
    MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
    menuItems.add(menuItem);
  }

  @Deprecated
  public ArrayList<MenuItem> getMenuItems() {
    return menuItems;
  }

  public Iterator<MenuItem> createIterator() {
    return menuItems.iterator();
  }
}

Interface d'itérateur :

public interface Iterator<T> {
  boolean hasNext();
  T next();
}

Classe d'itérateur :

public class DinerMenuIterator implements Iterator<MenuItem> {
  private MenuItem[] items;
  private int position = 0;

  public DinerMenuIterator(MenuItem[] items) {
    this.items = items;
  }

  @Override
  public boolean hasNext() {
    return position < items.length && items[position] != null;
  }

  @Override
  public MenuItem next() {
    return items[position++];
  }

  @Override
  public void remove() {
    if (position <= 0) {
      throw new IllegalStateException("You can&#39;t remove an item until you&#39;ve done at least one next()");
    }

    if (items[position - 1] != null) {
      for (int i = position - 1; i < items.length - 1; i++) {
        items[i] = items[i + 1];
      }
      items[items.length - 1] = null;
    }
  }
}
public class PancakeHouseIterator implements Iterator<MenuItem> {
  private ArrayList<MenuItem> items;
  private int position = 0;

  public PancakeHouseIterator(ArrayList<MenuItem> items) {
    this.items = items;
  }

  @Override
  public boolean hasNext() {
    return position < items.size();
  }

  @Override
  public MenuItem next() {
    return items.get(position++);
  }
}

Classe de serveur :

public class Waitress {
  private Menu<MenuItem> pancakeHouseMenu;
  private Menu<MenuItem> dinerMenu;

  public Waitress(Menu<MenuItem> pancakeHouseMenu, Menu<MenuItem> dinerMenu) {
    this.pancakeHouseMenu = pancakeHouseMenu;
    this.dinerMenu = dinerMenu;
  }

  public void printMenu() {
    Iterator<MenuItem> pancakeIterator = pancakeHouseMenu.createIterator();
    Iterator<MenuItem> dinerIterator = dinerMenu.createIterator();
    System.out.println("MENU\n----\nBREAKFAST");
    printMenu(pancakeIterator);
    System.out.println("\nLUNCH");
    printMenu(dinerIterator);

  }

  private void printMenu(Iterator<MenuItem> iterator) {
    while (iterator.hasNext()) {
      MenuItem menuItem = iterator.next();
      System.out.print(menuItem.getName() + ", ");
      System.out.print(menuItem.getPrice() + " -- ");
      System.out.println(menuItem.getDescription());
    }
  }
}

Au gré des possibilités vu du code ci-dessus, le serveur ne programme pas pour un menu spécifique, mais s'appuie sur une interface Menu qui crée un itérateur de menu et une interface itérateur Itérateur pour la programmation. Le serveur n'a pas besoin de connaître le type de méthode d'assemblage transmis. le menu ? Il vous suffit d'utiliser les objets de menu qui implémentent ces deux interfaces pour parcourir. Cela atteint l'objectif d'implémenter l'interface en s'appuyant sur le polymorphisme pour les modifications et en s'appuyant sur l'interface pour les modifications. Cela permet la séparation des serveurs et du menu. méthodes d'assemblage.

Le modèle itérateur peut être vu partout dans la collection de bibliothèques de classes Java. Le Menu utilisé ici est équivalent à l'interface Iterable de la bibliothèque de classes Java. Sa fonction est de créer un objet itérateur, et l'interface Iterator est la même. comme l'interface Iterator de la bibliothèque de classes Java. Fondamentalement la même. Ce qu'il faut expliquer ici, c'est que laisser une classe implémenter le modèle d'itérateur ajoute non seulement des fonctionnalités à une classe, mais augmente également la charge de maintenance de la classe, car la méthode de base de la classe est très cohérente et ce qu'on appelle La cohésion est l'implémentation d'un ensemble complet de fonctions liées, et l'interface de l'itérateur est en fait un ensemble complet de fonctions liées. Par conséquent, laisser une classe implémenter le modèle d'itérateur ajoute implicitement deux ensembles de fonctions moins « cohésives » à la classe. ce qui conduira à la nécessité de prendre en compte les deux côtés lors du maintien des fonctions de cette classe. Cela se reflète dans la bibliothèque de classes Java ArrayList et LinkedList. Elle fournit non seulement toutes les méthodes de suppression de base de List, mais fournit également la méthode de suppression qui doit être implémentée par les itérateurs afin de réaliser l'unification des deux. pour établir certaines conventions. Par exemple, lors de la traversée d'une collection, vous ne pouvez pas appeler les méthodes de base de suppression ou d'ajout de la classe qui modifieront la structure de la classe.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!