迭代器模式：提供一种方法顺序访问一个聚合对象（array、list等）中的各个元素，而又不暴露其内部的表示。
一旦实现迭代器，我们只需要一个循环，就可以多态地处理任何项的集合。
有两个系统：绩效查询系统，工资单查询系统。
绩效查询系统（PerformanceSystem），拥有公司所有的员工信息，使用数组实现。
工资查询系统（SalarySystem），拥有公司所有的员工信息，使用List实现。
我们必须使用两个循环遍历这两个系统的人员信息。
使用迭代器模式，使用一种方法就可以访问所有系统的人员信息，而且不需要关心各个系统的人员数据结构。
package com.ez.biz;
/**
* @author 窗外赏雪（EZ编程网）
*/
public class Test {
public static void main(String[] args) {
PerformanceSystem ps = new PerformanceSystem();
SalarySystem ss = new SalarySystem();
Programmer programmer = new Programmer(ps, ss);
System.out.println("======对照系统间的人员信息=====");
programmer.comparePeople();
}
}
package com.ez.biz;
import com.ez.ApplicationSystem;
import com.ez.Iterator;
/**
* 程序员需要隔段时间检查下两个系统的人员数据是否一致。 程序员不需要知道系统是使用数组还是List来实现的，他只关心取到迭代器。
*
* @author 窗外赏雪（EZ编程网）
*/
public class Programmer {
private ApplicationSystem performanceSystem;
private ApplicationSystem salarySystem;
public Programmer(ApplicationSystem performanceSystem,
ApplicationSystem salarySystem) {
this.performanceSystem = performanceSystem;
this.salarySystem = salarySystem;
}
/**
* 对照系统间的人员信息
* 实现迭代器，我们只需要一个循环，就可以多态地处理任何项的集合。
*/
public void comparePeople() {
Iterator performanceIterator = performanceSystem.createIterator();
Iterator salaryIterator = salarySystem.createIterator();
System.out.println("绩效系统的人员列表");
printPeople(performanceIterator);
System.out.println("工资系统的人员列表");
printPeople(salaryIterator);
}
private void printPeople(Iterator iterator) {
while (iterator.hasNext()) {
People people = (People) iterator.next();
System.out.println(people.getName());
}
}
}
package com.ez;
/**
* 使用迭代器系统接口
* @author 窗外赏雪（EZ编程网）
*/
public interface ApplicationSystem {
Iterator createIterator();
}
package com.ez.biz;
import com.ez.Iterator;
import com.ez.ApplicationSystem;
import com.ez.impl.ArrayIterator;
/**
* 绩效系统
* 实现创建迭代器，返回数组迭代器。
* @author 窗外赏雪（EZ编程网）
*/
public class PerformanceSystem implements ApplicationSystem{
static final int MAX_COUNT=10;
private People[] peoples;
public PerformanceSystem() {
peoples=new People[MAX_COUNT];
peoples[0]=new People("李四",19);
peoples[1]=new People("王五",24);
peoples[2]=new People("赵六",13);
peoples[3]=new People("孙七",42);
}
public Iterator createIterator(){
return new ArrayIterator(peoples);
}
}
package com.ez.biz;
import java.util.ArrayList;
import java.util.List;
import com.ez.Iterator;
import com.ez.ApplicationSystem;
import com.ez.impl.ListIterator;
/**
* 工资系统
* 实现创建迭代器，返回List迭代器。
* @author 窗外赏雪（EZ编程网）
*/
public class SalarySystem implements ApplicationSystem{
private List<People> peoples;
public SalarySystem() {
peoples=new ArrayList<People>();
peoples.add(new People("李四",19));
peoples.add(new People("王五",24));
peoples.add(new People("赵六",13));
peoples.add(new People("孙七",42));
}
public Iterator createIterator(){
return new ListIterator(peoples);
}
}
package com.ez.biz;
/**
*
* @author 窗外赏雪（EZ编程网）
*/
public class People {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public People(String name, int age) {
this.name = name;
this.age = age;
}
}
package com.ez;
/**
* 迭代器接口
* @author 窗外赏雪（EZ编程网）
*/
public interface Iterator {
/**
* 是否还有更多的元素
* @return
*/
boolean hasNext();
/**
* 返回下一个元素
* @return
*/
Object next();
}
package com.ez.impl;
import com.ez.Iterator;
import com.ez.biz.People;
/**
* 专门用于迭代数组类型的人员信息。
* @author 窗外赏雪（EZ编程网）
*/
public class ArrayIterator implements Iterator {
private People[] peoples;
private int position = 0;
public ArrayIterator(People[] peoples) {
this.peoples = peoples;
}
@Override
public boolean hasNext() {
if (position >= peoples.length || peoples[position] == null) {
return false;
} else {
return true;
}
}
@Override
public Object next() {
People people = peoples[position];
position++;
return people;
}
}
package com.ez.impl;
import java.util.List;
import com.ez.Iterator;
import com.ez.biz.People;
/**
* 专门用于迭代List类型的人员信息。
* @author 窗外赏雪（EZ编程网）
*/
public class ListIterator implements Iterator {
private List<People> peoples;
private int position = 0;
public ListIterator(List<People> peoples) {
this.peoples = peoples;
}
@Override
public boolean hasNext() {
// TODO Auto-generated method stub
if (position >= peoples.size() || peoples.get(position) == null) {
return false;
} else {
return true;
}
}
@Override
public Object next() {
People people = peoples.get(position);
position++;
return people;
}
}
使用Java自带的Iterator接口，实现迭代器模式。
package com.ez.biz;
/**
* @author 窗外赏雪（EZ编程网）
*/
public class Test {
public static void main(String[] args) {
PerformanceSystem ps = new PerformanceSystem();
SalarySystem ss = new SalarySystem();
AttendanceSystem as = new AttendanceSystem();
Programmer programmer = new Programmer(ps, ss, as);
System.out.println("======对照系统间的人员信息=====");
programmer.comparePeople();
}
}
package com.ez;
import java.util.Iterator;
/**
* 使用迭代器系统接口
* @author 窗外赏雪（EZ编程网）
*/
public interface ApplicationSystem {
Iterator createIterator();
}
package com.ez.biz;
import java.util.Hashtable;
import java.util.Iterator;
import com.ez.ApplicationSystem;
/**
* 考勤系统
* Collection间接实现了一个返回迭代器的iterator()方法
* @author 窗外赏雪（EZ编程网）
*/
public class AttendanceSystem implements ApplicationSystem{
private Hashtable<String,People> peoples;
public AttendanceSystem() {
peoples=new Hashtable<String,People>();
peoples.put("李四",new People("李四",19));
peoples.put("王五",new People("王五",24));
peoples.put("赵六",new People("赵六",13));
peoples.put("孙七",new People("孙七",42));
}
public Iterator<People> createIterator(){
return peoples.values().iterator();
}
}
package com.ez.biz;
import java.util.Iterator;
import com.ez.ApplicationSystem;
import com.ez.impl.ArrayIterator;
/**
* 绩效系统
* 实现创建迭代器，返回数组迭代器。
* @author 窗外赏雪（EZ编程网）
*/
public class PerformanceSystem implements ApplicationSystem{
static final int MAX_COUNT=10;
private People[] peoples;
public PerformanceSystem() {
peoples=new People[MAX_COUNT];
peoples[0]=new People("李四",19);
peoples[1]=new People("王五",24);
peoples[2]=new People("赵六",13);
peoples[3]=new People("孙七",42);
}
public Iterator createIterator(){
return new ArrayIterator(peoples);
}
}
package com.ez.biz;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import com.ez.ApplicationSystem;
/**
* 工资系统
* ArrayList已经实现了一个返回迭代器的iterator()方法
* @author 窗外赏雪（EZ编程网）
*/
public class SalarySystem implements ApplicationSystem{
private List<People> peoples;
public SalarySystem() {
peoples=new ArrayList<People>();
peoples.add(new People("李四",19));
peoples.add(new People("王五",24));
peoples.add(new People("赵六",13));
peoples.add(new People("孙七",42));
}
public Iterator<People> createIterator(){
return peoples.iterator();
}
}
package com.ez.impl;
import java.util.Iterator;
import com.ez.biz.People;
/**
* 专门用于迭代数组类型的人员信息，实现java.util的迭代器接口。
* @author 窗外赏雪（EZ编程网）
*/
public class ArrayIterator implements Iterator {
private People[] peoples;
private int position = 0;
public ArrayIterator(People[] peoples) {
this.peoples = peoples;
}
@Override
public boolean hasNext() {
if (position >= peoples.length || peoples[position] == null) {
return false;
} else {
return true;
}
}
@Override
public Object next() {
People people = peoples[position];
position++;
return people;
}
@Override
public void remove() {
}
}
package com.ez.biz;
import java.util.Iterator;
import com.ez.ApplicationSystem;
/**
* 程序员需要隔段时间检查下两个系统的人员数据是否一致。
* 程序员不需要知道系统是使用数组还是List来实现的，他只关心取到迭代器。
* @author 窗外赏雪（EZ编程网）
*/
public class Programmer {
private ApplicationSystem performanceSystem;
private ApplicationSystem salarySystem;
private ApplicationSystem attendanceSystem;
public Programmer(ApplicationSystem performanceSystem,
ApplicationSystem salarySystem, ApplicationSystem attendanceSystem) {
this.performanceSystem = performanceSystem;
this.salarySystem = salarySystem;
this.attendanceSystem = attendanceSystem;
}
/**
* 对照系统间的人员信息 实现迭代器，我们只需要一个循环，就可以多态地处理任何项的集合。
*/
public void comparePeople() {
Iterator performanceIterator = performanceSystem.createIterator();
Iterator salaryIterator = salarySystem.createIterator();
Iterator attendanceIterator = attendanceSystem.createIterator();
System.out.println("绩效系统的人员列表");
printPeople(performanceIterator);
System.out.println("工资系统的人员列表");
printPeople(salaryIterator);
System.out.println("考勤系统的人员列表");
printPeople(attendanceIterator);
}
private void printPeople(Iterator iterator) {
while (iterator.hasNext()) {
People people = (People) iterator.next();
System.out.println(people.getName());
}
}
}
Collection和Iterator的好处在于，每个Collection都知道如何创建自己的Iterator。例如，只要调用ArrayList上的iterator()，就可以返回一个具体的Iterator。
Java5 包含一种新形式的for语句，称为for/in。可以让你在一个集合或者一个数组中遍历，而不需要显式创建迭代器。
程序员调了三次createIterator()，printPeople(Iterator)。
我们可以把这些系统打包进一个List中，然后取到它的迭代器，遍历每个系统，这样，程序员代码就变得很简单，并且新增删除应用都不用修改代码。
优化后的程序员代码：
package com.ez.biz;
import java.util.Iterator;
import java.util.List;
import com.ez.ApplicationSystem;
/**
* 程序员升级版
* 我们把系统打包进一个List中，这样我们可以通过迭代器，遍历每个系统。
* @author 窗外赏雪（EZ编程网）
*/
public class ProgrammerUpgrade {
private List<ApplicationSystem> applicationSystems;
public ProgrammerUpgrade(List<ApplicationSystem> applicationSystem) {
this.applicationSystems=applicationSystem;
}
/**
* 对照系统间的人员信息 实现迭代器，我们只需要一个循环，就可以多态地处理任何项的集合。
*/
public void comparePeople() {
Iterator systemIterator = applicationSystems.iterator();
while(systemIterator.hasNext()){
ApplicationSystem as=(ApplicationSystem)systemIterator.next();
System.out.println("=============================");
printPeople(as.createIterator()); //每个系统的迭代器
}
}
private void printPeople(Iterator iterator) {
while (iterator.hasNext()) {
People people = (People) iterator.next();
System.out.println(people.getName());
}
}
}
相关推荐
迭代器模式是软件设计模式中的一种行为模式，它在编程中扮演着重要的角色，尤其是在处理集合数据时。迭代器模式的核心思想是提供一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。这种模式使得用户可以在不...
迭代器模式 迭代器模式是23种设计模式之一，属于行为型模式。它提供了一种访问聚合对象元素的方式，而不需要暴露该对象的内部实现。迭代器模式的主要目的是让开发者能够轻松地遍历聚合对象中的元素，而不需要关心...
迭代器模式是一种设计模式，它在软件工程中扮演着重要的角色，特别是在处理集合或容器类对象的遍历操作时。这种模式提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。在Java、C#等面向对象语言中，...
迭代器模式是软件设计模式中的一种行为模式，它允许我们顺序访问聚合对象的元素，而无需暴露其底层表示。在Java、C#等面向对象语言中，迭代器模式被广泛应用于容器类，如ArrayList、LinkedList等，使得我们可以方便...
迭代器模式是一种行为设计模式，它提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。这种模式允许我们遍历集合中的每个元素，同时保持集合本身抽象，不需了解其内部结构。 在Java、C#等面向对象语言...
迭代器模式是一种行为设计模式，它提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。在Java中，迭代器模式是通过接口实现的，这使得我们可以遍历任何实现了`Iterable`接口的对象，例如集合框架中的`...
迭代器模式是软件设计模式中的一种行为模式，它在C#等面向对象编程语言中有着广泛的应用。这个模式的主要目标是允许用户遍历一个聚合对象（如数组、集合或列表）的所有元素，而无需了解底层的实现细节。下面将详细...
在这个主题中，我们主要探讨了如何利用组合模式（Composite Pattern）构建二叉树，并通过迭代器模式（Iterator Pattern）来实现对树的遍历，包括前序、中序和后序遍历。这些是设计模式中的经典应用，对于理解和掌握...
迭代器模式是一种设计模式，属于行为设计模式，它允许我们顺序访问聚合对象的元素，而无需暴露其底层表示。在Java、C#等面向对象语言中，迭代器模式被广泛应用于容器类，如ArrayList、LinkedList等，使得我们可以...
迭代器模式是一种行为设计模式，主要目的是在不暴露集合内部结构的情况下，允许外部代码遍历集合的所有元素。这种模式将遍历操作从集合类中分离出来，实现了数据结构和遍历机制的解耦。在大多数编程语言中，迭代器...
迭代器模式是一种行为设计模式，它允许我们顺序访问聚合对象的元素，而无需暴露其底层表示。在Java、Python、C#等编程语言中，迭代器模式被广泛应用于集合类，如ArrayList、LinkedList等，提供了统一的遍历接口，...
迭代器模式是一种设计模式，它提供了一种方法来顺序访问聚合对象的元素，而又不暴露其底层表示。在Headfirst的第九章中，这个模式通过C++语言进行了深入的探讨和实现，同时辅以UML类图进行可视化展示，帮助读者更好...
### (行为型模式) Iterator 迭代器模式 #### 概述 在软件工程领域，设计模式被广泛应用于解决常见的编程问题。其中，“迭代器模式”作为一种行为型设计模式，在处理集合类对象时发挥着重要作用。本文将详细介绍...
迭代器模式是软件设计模式中的一种行为模式，它允许我们顺序访问聚合对象的元素，而无需暴露其底层表示。在Java中，迭代器模式广泛应用于集合框架，如List、Set和Map接口，使得程序员可以方便地遍历集合中的元素。 ...
迭代器模式（Iterator Pattern）是Java设计模式中的行为模式之一，它提供了一种方法来顺序访问聚合对象的元素，而又不暴露其底层表示。在Java中，迭代器模式被广泛应用于集合类，如ArrayList、LinkedList等，通过...
迭代器模式是一种行为设计模式，它允许我们顺序访问聚合对象的元素，而无需暴露其底层表示。在Java中，迭代器模式广泛应用于集合框架，如ArrayList、LinkedList等。本示例将深入探讨如何在Java中实现和使用迭代器...
迭代器模式是软件设计模式中的一种，它在对象集合的遍历访问中起着关键作用。这个模式的主要目的是提供一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。迭代器模式允许你遍历任何聚合对象，无论它的内部...
一个聚合对象，如一个列表(List)或者一个集合(Set)，应该提供一种方法来让别人可以访问它...怎样遍历一个聚合对象，又不需要了解聚合对象的内部结构，还能够提供多种不同的遍历方式，这就是迭代器模式所要解决的问题。