Modèle d'itérateur en Java

introduction

Présentation des modèles de conception de [GoF](https://ja.wikipedia.org/wiki/Gang of for _ (Information Engineering)) ["Introduction aux modèles de conception appris dans le langage Java augmenté et révisé"]( https://www.amazon.co.jp/ Édition augmentée et révisée Introduction aux modèles de conception appris en langage Java-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _ Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP) Je vais résumer sur.

Modèle d'itérateur

Qu'est-ce que Iterator

Iterator est un mot anglais qui signifie «** répéteur » en japonais. Surtout en programmation, cela signifie une abstraction et une généralisation de " pointant les choses **" lors de l'accès aux agrégats en séquence. Je pense qu'il est difficile de saisir l'image à partir de cette seule explication, je vais donc donner un exemple plus concret. Je pense que beaucoup de gens ont écrit des déclarations répétitives qui affichent tous les éléments du tableau ʻarray` comme indiqué ci-dessous.

sample.java

for (int i = 0; i < array.length; i++) {
  System.out.println(array[i]);
}

Ici, la variable ʻi devient un indice du tableau ʻarray, et les éléments du tableau sont accédés en séquence. De cette façon, l'itérateur est "** pointant à plusieurs reprises vers le tout et scanne **".

Personnage

Le modèle Itarator utilise les classes et les interfaces qui apparaissent dans le diagramme de classes ci-dessous.

interface

• Aggreate
  Représente l '«agrégat» à compter. Il n'a que ʻIterator () `comme méthode. Ceci est utilisé pour générer un itérateur.

Aggregate.java

public interface Aggregate {
	public abstract Iterator iterator();
}

• Iterator
  Représente le "compteur" des éléments de l'ensemble. Il a deux méthodes, hasNext () et next (). Utilisez hasNext () pour voir s'il contient les éléments suivants: next () est utilisé pour obtenir l'élément suivant lorsqu'il est présent.

Iterator.java

public interface Iterator {
	public abstract boolean hasNext();

	public abstract Object next();
}

Classe d'implémentation

Implémentez l'interface et décrivez le traitement spécifique. Des exemples spécifiques seront décrits plus loin.

• ConcreateAggreate
• ConcreateIterator

Exemple concret

À titre d'exemple concret, l'explication est basée sur "** Liste d'employés qui récapitule les employés " et " Itérateur de liste d'employés **".

Classe d'implémentation

• ** Classe d'employé ** La classe Employee représente un élément de l'agrégat. Avoir un nom et un code d'employé.

Employee.java

public class Employee {
	private String name;
	private String employeeCode;

	public Employee(String name, String employeeCode) {
		this.name = name;
		this.employeeCode = employeeCode;
	}

	public String getName() {
		return name;
	}

	public String getEmployeeCode() {
		return employeeCode;
	}
}

• ** Classe EmployeeList ** La classe EmployeeList représente une collection d'employés. Il a un éventail d'employés et d'abonnés. ʻEmployeeListIteratorest généré et renvoyé avec lui-même comme argument dans ʻiterator ().

EmployeeList.java

public class EmployeeList implements Aggregate {
	private Employee[] employees;
	private int last = 0;

	public EmployeeList(int maxsize) {
		this.employees = new Employee[maxsize];
	}

	public Employee getEmployeeAt(int index) {
		return employees[index];
	}

	public void appendEmployee(Employee employee) {
		this.employees[last] = employee;
		last++;
	}

	public int getLength() {
		return last;
	}

	public Iterator iterator() {
		return new EmployeeListIterator(this);
	}
}

• ** Classe EmployeeListIterator ** La classe EmployeeListIterator représente le décompte d'une collection d'employés. Avoir une liste d'employés et des abonnés. hasNext () vérifie si la liste d'employés a l'élément suivant, et next () retourne l'élément suivant (employé) de la liste d'employés. Il existe différentes manières d'accéder en séquence, mais cette fois nous allons simplement implémenter l'accès en séquence d'avant **.

EmployeeListIterator.java

public class EmployeeListIterator implements Iterator {
	private EmployeeList employeeList;
	private int index;

	public EmployeeListIterator(EmployeeList employeeList) {
		this.employeeList = employeeList;
		this.index = 0;
	}

	public boolean hasNext() {
		if (index < employeeList.getLength()) {
			return true;
		} else {
			return false;
		}
	}

	public Object next() {
		Employee employee = employeeList.getEmployeeAt(index);
		index++;
		return employee;
	}
}

Classe d'exécution

• ** Classe principale ** Les employés sont ajoutés à la liste des employés et le nom et le code d'employé de l'employé ajouté sont sortis de la liste des employés.

Main.java

public class Main {
	public static void main(String[] args) {
		EmployeeList employeeList = new EmployeeList(4);
		employeeList.appendEmployee(new Employee("Tarou_Tanaka", "C001"));
		employeeList.appendEmployee(new Employee("Hanako_Yamada", "C002"));
		employeeList.appendEmployee(new Employee("Yuuya_Suzuki", "C003"));
		employeeList.appendEmployee(new Employee("Kanako_Satou", "C004"));
		Iterator it = employeeList.iterator();
		while (it.hasNext()) {
			Employee employee = (Employee) it.next();
			System.out.println(employee.getName() + ":" + employee.getEmployeeCode());
		}
	}
}

Résultat d'exécution

Le résultat de l'exécution de «Main.class» est le suivant. Vous pouvez voir que la sortie est correcte dans l'ordre dans lequel ils ont été ajoutés à ʻemployeeList`.

Résultat d'exécution

Tarou_Tanaka:C001
Hanako_Yamada:C002
Yuuya_Suzuki:C003
Kanako_Satou:C004

mérite

En utilisant Iterator, vous n'avez pas besoin d'être conscient du type d'agrégat (tableau, ArrayList, Vector, etc.) et du type d'implémentation effectué lors du comptage. Ci-dessous, nous définissons ʻEmployeeList.class, qui change l'agrégat d'un tableau en ArrayList. Pour le moment, il n'est pas nécessaire de modifier la classe d'exécution Main.class`, et le résultat de l'exécution est le même que pour un tableau.

EmployeeList.java

import java.util.ArrayList;

public class EmployeeList implements Aggregate {
	private ArrayList<Employee> employees;

	public EmployeeList(int initialsize) {
		this.employees = new ArrayList<>(initialsize);
	}

	public Employee getEmployeeAt(int index) {
		return (Employee) employees.get(index);
	}

	public void appendEmployee(Employee employee) {
		employees.add(employee);
	}

	public int getLength() {
		return employees.size();
	}

	public Iterator iterator() {
		return new EmployeeListIterator(this);
	}
}

Résultat d'exécution

Tarou_Tanaka:C001
Hanako_Yamada:C002
Yuuya_Suzuki:C003
Kanako_Satou:C004

Postscript (31/10/2018)

Il existe différentes manières d'accéder à Iterator autres que d'y accéder séquentiellement depuis l'avant. (Ordre inverse, en sauter un, etc.) Cette fois, nous avons ajouté Iterator pour accéder dans l'ordre inverse avec ArrayList. Seules les classes présentant des différences seront publiées, donc pour les autres classes [Résumé](https://qiita.com/mk777/items/398bd26de44eac4f383b#%E3%81%BE%E3%81%A8%E3%82% Veuillez vous enregistrer 81).

interface

• Aggregate
  Nous ajoutons un reverseIterator () qui générera un Iterator pour y accéder dans l'ordre inverse.

Aggregate.class

public interface Aggregate {
	public abstract Iterator iterator();

	public abstract Iterator reverseIterator();
}

Classe d'implémentation

• ** Classe EmployeeList ** Nous ajoutons reverseIterator (). Dans reverseIterator (), ʻEmployeeListReverseIterator` est généré et renvoyé avec lui-même comme argument.

EmployeeList.class

import java.util.ArrayList;

public class EmployeeList implements Aggregate {
	private ArrayList<Employee> employees;

	public EmployeeList(int initialsize) {
		this.employees = new ArrayList<>(initialsize);
	}

	public Employee getEmployeeAt(int index) {
		return (Employee) employees.get(index);
	}

	public void appendEmployee(Employee employee) {
		employees.add(employee);
	}

	public int getLength() {
		return employees.size();
	}

	public Iterator iterator() {
		return new EmployeeListIterator(this);
	}

	public Iterator reverseIterator() {
		return new EmployeeListReverseIterator(this);
	}
}

• ** Classe EmployeeListReverseIterator ** Bien que ce soit une classe nouvellement créée, elle implémente hasNext () et next () de la même manière que ʻEmployeeListIterator.class qui accède séquentiellement. Le constructeur a le nombre d'éléments dans ʻemployeeList moins 1 dans ʻindex. En conséquence, 4 seront obtenus à partir de la liste avec 5 éléments. hasNext () accède dans l'ordre inverse autant que le nombre d'éléments dans ArrayList. Il convient de noter que ** la condition de boucle doit garantir que ʻindex n'est pas inférieur à 0 **. Sans cette condition, next () essaiera d'accéder à employeeList [-1] et ʻArrayIndexOutOfBoundsException` se produira.

EmployeeListReverseIterator.class

public class EmployeeListReverseIterator implements Iterator {
	private EmployeeList employeeList;
	private int index;

	public EmployeeListReverseIterator(EmployeeList employeeList) {
		this.employeeList = employeeList;
		this.index = employeeList.getLength() - 1;
	}

	public boolean hasNext() {
		if (index < employeeList.getLength() && index >= 0) {
			return true;
		} else {
			return false;
		}
	}

	public Object next() {
		Employee employee = employeeList.getEmployeeAt(index);
		index--;
		return employee;
	}
}

Classe d'exécution

• ** Classe principale ** Après avoir ajouté ʻEmployee à ʻEmployee List et sorti en séquence, la sortie est effectuée dans l'ordre inverse.

Main.class

public class Main {
	public static void main(String[] args) {
		EmployeeList employeeList = new EmployeeList(4);
		employeeList.appendEmployee(new Employee("Tarou_Tanaka", "C001"));
		employeeList.appendEmployee(new Employee("Hanako_Yamada", "C002"));
		employeeList.appendEmployee(new Employee("Yuuya_Suzuki", "C003"));
		employeeList.appendEmployee(new Employee("Kanako_Satou", "C004"));
		Iterator it = employeeList.iterator();
		System.out.println("------- Order -------");
		while (it.hasNext()) {
			Employee employee = (Employee) it.next();
			System.out.println(employee.getName() + ":" + employee.getEmployeeCode());
		}
		System.out.println("------- Reverse Order -------");
		Iterator rit = employeeList.reverseIterator();
		while (rit.hasNext()) {
			Employee employee = (Employee) rit.next();
			System.out.println(employee.getName() + ":" + employee.getEmployeeCode());
		}
	}
}

Résultat d'exécution

Le résultat de l'exécution de «Main.class» est le suivant. Vous pouvez voir que la sortie est dans l'ordre ** ajouté à ʻemployeeList` et dans l'ordre inverse ** avec ceux ajoutés.

Résultat d'exécution

------- Order -------
Tarou_Tanaka:C001
Hanako_Yamada:C002
Yuuya_Suzuki:C003
Kanako_Satou:C004
------- Reverse Order -------
Kanako_Satou:C004
Yuuya_Suzuki:C003
Hanako_Yamada:C002
Tarou_Tanaka:C001

Résumé

Vous avez découvert le modèle Iterator, qui accède aux agrégats en séquence. L'exemple de code est téléchargé ci-dessous, veuillez donc vous y référer si vous le souhaitez.

• Exemple de code Iterator

En outre, d'autres modèles de conception sont résumés ci-dessous, veuillez donc vous y référer également.

• [Mis à jour de temps en temps] Résumé des modèles de conception en Java

Les références

• [Introduction aux modèles de conception appris dans le langage Java augmenté et révisé](https://www.amazon.co.jp/ Introduction aux modèles de conception appris dans le langage Java augmenté et révisé-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP)