[GO] Iteratormuster in Java

Einführung

Einführung in die Entwurfsmuster von [GoF](https://ja.wikipedia.org/wiki/Gang von for _ (Information Engineering)) ["Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden"]( https://www.amazon.co.jp/ Erweiterte und überarbeitete Ausgabe Einführung in Entwurfsmuster, die in der Java-Sprache gelernt wurden-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _ Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5M Ich werde über zusammenfassen.

Iteratormuster

Was ist Iterator?

Iterator ist ein englisches Wort, das auf Japanisch "** Repeater " bedeutet. Insbesondere in der Programmierung bedeutet dies eine Abstraktion und Verallgemeinerung von " zeigenden Dingen **" beim Zugriff auf Aggregate nacheinander. Ich denke, es ist schwierig, das Bild allein aus dieser Erklärung zu erfassen, deshalb werde ich ein konkreteres Beispiel geben. Ich denke, viele Leute haben sich wiederholende Anweisungen geschrieben, die alle Elemente des Arrays "Array" anzeigen, wie unten gezeigt.

sample.java

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

Hier wird die Variable "i" ein Index des Arrays "Array", und auf die Elemente des Arrays wird nacheinander zugegriffen. Auf diese Weise zeigt der Iterator "** wiederholt auf das Ganze und scannt **".

Charakter

Das Itarator-Muster verwendet die Klassen und Schnittstellen, die im folgenden Klassendiagramm angezeigt werden.

Schnittstelle

• Aggreate
  Stellt das zu zählende "Aggregat" dar. Es hat nur "Iterator ()" als Methode. Dies wird verwendet, um einen Iterator zu erzeugen.

Aggregate.java

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

• Iterator
  Repräsentiert den "Zähler" der Elemente der Menge. Es gibt zwei Methoden: "hasNext ()" und "next ()". Verwenden Sie "hasNext ()", um festzustellen, ob die folgenden Elemente vorhanden sind: next () wird verwendet, um das nächste Element abzurufen, wenn es vorhanden ist.

Iterator.java

public interface Iterator {
	public abstract boolean hasNext();

	public abstract Object next();
}

Implementierungsklasse

Implementieren Sie die Schnittstelle und beschreiben Sie die spezifische Verarbeitung. Spezifische Beispiele werden später beschrieben.

• ConcreateAggreate
• ConcreateIterator

Konkretes Beispiel

Als konkretes Beispiel basiert die Erklärung auf "** Mitarbeiterliste, in der Mitarbeiter ** zusammengefasst sind" und "** Mitarbeiterliste Iterator **".

Implementierungsklasse

• ** Mitarbeiterklasse ** Die Employee-Klasse repräsentiert ein Element des Aggregats. Haben Sie einen Namen und einen Mitarbeitercode.

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;
	}
}

• ** EmployeeList-Klasse ** Die EmployeeList-Klasse repräsentiert eine Sammlung von Mitarbeitern. Es hat eine Reihe von Mitarbeitern und Indizes. In iterator () wird EmployeeListIterator generiert und mit sich selbst als Argument zurückgegeben.

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);
	}
}

• ** EmployeeListIterator-Klasse ** Die EmployeeListIterator-Klasse repräsentiert eine Anzahl von Mitarbeitern. Haben Sie eine Mitarbeiterliste und Indizes. hasNext () prüft, ob die Mitarbeiterliste das nächste Element enthält, und next () gibt das nächste Element (Mitarbeiter) der Mitarbeiterliste zurück. Es gibt verschiedene Möglichkeiten, nacheinander zuzugreifen, aber diesmal implementieren wir den Zugriff einfach nacheinander von vor **.

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;
	}
}

Ausführungsklasse

-** Hauptklasse ** Mitarbeiter werden zur Mitarbeiterliste hinzugefügt, und der Name und der Mitarbeitercode des hinzugefügten Mitarbeiters werden aus der Mitarbeiterliste ausgegeben.

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());
		}
	}
}

Ausführungsergebnis

Das Ergebnis der Ausführung von "Main.class" ist wie folgt. Sie können sehen, dass die Ausgabe in der Reihenfolge korrekt ist, in der sie zur employeeList hinzugefügt wurden.

Ausführungsergebnis

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

verdienen

Wenn Sie Iterator verwenden, müssen Sie nicht wissen, um welche Art von Aggregat es sich handelt (Array, ArrayList, Vector usw.) und welche Art der Implementierung beim Zählen erfolgt. Im Folgenden wird "EmployeeList.class" definiert, mit der das Aggregat von einem Array in eine ArrayList geändert wird. Zu diesem Zeitpunkt muss die Ausführungsklasse "Main.class" nicht geändert werden, und das Ausführungsergebnis ist das gleiche wie für ein Array.

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);
	}
}

Ausführungsergebnis

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

Nachtrag (31.10.2018)

Es gibt verschiedene Möglichkeiten, auf Iterator zuzugreifen, außer von vorne nacheinander darauf zuzugreifen. (Reihenfolge umkehren, eine überspringen usw.) Dieses Mal haben wir Iterator hinzugefügt, um mit ArrayList in umgekehrter Reihenfolge darauf zuzugreifen. Es werden nur die Klassen mit Unterschieden veröffentlicht, also für andere Klassen [Zusammenfassung](https://qiita.com/mk777/items/398bd26de44eac4f383b#%E3%81%BE%E3%81%A8%E3%82% Bitte checken Sie in 81).

Schnittstelle

• Aggregate
  Ich füge "reverseIterator ()" hinzu, um einen Iterator zu generieren, der in umgekehrter Reihenfolge zugreift.

Aggregate.class

public interface Aggregate {
	public abstract Iterator iterator();

	public abstract Iterator reverseIterator();
}

Implementierungsklasse

• ** EmployeeList-Klasse ** Wir fügen reverseIterator () hinzu. In reverseIterator () wird EmployeeListReverseIterator generiert und mit sich selbst als Argument zurückgegeben.

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);
	}
}

• ** EmployeeListReverseIterator-Klasse ** Obwohl es sich um eine neu erstellte Klasse handelt, implementiert sie "hasNext ()" und "next ()" auf dieselbe Weise wie "EmployeeListIterator.class", die nacheinander zugreift. Der Konstruktor hat die Anzahl der Elemente in employeeList minus 1 in index. Als Ergebnis werden 4 aus der Liste mit 5 Elementen erhalten. hasNext () greift aus der umgekehrten Reihenfolge auf die Anzahl der Elemente in ArrayList zu. Beachten Sie, dass ** die Schleifenbedingung sicherstellen muss, dass index nicht kleiner als 0 ** ist. Ohne diese Bedingung versucht next (), auf employeeList [-1] zuzugreifen, und es tritt eine ArrayIndexOutOfBoundsException auf.

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;
	}
}

Ausführungsklasse

-** Hauptklasse ** Nach dem Hinzufügen von "Employee" zu "EmployeeList" und der Ausgabe nacheinander erfolgt die Ausgabe in umgekehrter Reihenfolge.

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());
		}
	}
}

Ausführungsergebnis

Das Ergebnis der Ausführung von "Main.class" ist wie folgt. Sie können sehen, dass die Ausgabe in der Reihenfolge ** erfolgt, die der Mitarbeiterliste hinzugefügt wurde, und in umgekehrter Reihenfolge ** mit den hinzugefügten.

Ausführungsergebnis

------- 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

Zusammenfassung

Sie haben das Iteratormuster kennengelernt, das nacheinander auf Aggregate zugreift. Der Beispielcode wird unten hochgeladen. Wenn Sie möchten, lesen Sie ihn bitte.

• Iterator-Beispielcode

Darüber hinaus sind nachfolgend weitere Entwurfsmuster zusammengefasst. Bitte beziehen Sie sich auch auf diese.

• [Von Zeit zu Zeit aktualisiert] Zusammenfassung der Entwurfsmuster in Java

Verweise

• [Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden](https://www.amazon.co.jp/ Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP)