迭代器模式：提供一种方法顺序访问一个聚合对象（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());
}
}
}
相关推荐
迭代器模式是软件设计模式中的一种行为模式，它在编程中扮演着重要的角色，尤其是在处理集合数据时。迭代器模式的核心思想是提供一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。这种模式使得用户可以在不...
迭代器模式是软件开发中广泛使用的设计模式之一，特别是在处理聚合数据结构如数组、列表和集合时。迭代器模式可以提供一种统一的方式来遍历这些结构中的元素，从而使得开发者不需要关心聚合对象的内部实现细节。通过...
迭代器模式是一种设计模式，它在软件工程中扮演着重要的角色，特别是在处理集合或容器类对象的遍历操作时。这种模式提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。在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)，应该提供一种方法来让别人可以访问它...怎样遍历一个聚合对象，又不需要了解聚合对象的内部结构，还能够提供多种不同的遍历方式，这就是迭代器模式所要解决的问题。