迭代器模式_while (iterator.hasnext())-CSDN博客

本文链接：https://blog.csdn.net/weixin_47382783/article/details/109332571

一、迭代器模式的介绍

1、定义

迭代器模式提供了一种方法顺序访问一个聚合对象中的各个元素，而又无需暴露该对象的内部实现，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

迭代器模式是针对集合对象而生的，对于集合对象而言，肯定会涉及到对集合的添加和删除操作，同时也肯定支持遍历集合元素的操作，我们此时可以把遍历操作放在集合对象中，但这样的话，集合对象就会承担太多的责任，所以我们要尽可能地分离这些职责，用不同的类去承担不同的责任，通过使用迭代类来承担遍历集合的职责。

迭代器模式的角色划分：

抽象迭代器角色（Iterator）：该角色负责定义访问和遍历元素的接口。
具体迭代器角色（Concrete Iterator）：该角色实现Iterator接口，完成容器元素的遍历。
抽象聚集角色（Aggregate）：该角色提供创建迭代器角色的接口。
具体聚集角色（Concrete Aggregate）：该角色实现抽象聚集接口，创建出容纳迭代器的对象。

迭代器模式的类图如下：

2、使用场景

当需要为聚合对象提供多种遍历方式时。
当需要为遍历不同的聚合结构提供一个统一的接口时。
当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

3、优缺点

（1）优点

支持以不同的方式遍历一个聚合对象。
迭代器简化了聚合类。
在同一给聚合上可以有多个遍历。
在迭代器模式中，增加新的聚合类和迭代器类都很方便，无需修改原有代码。

（2）缺点

由于存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，使得系统中类的个数成对增加，增加了系统的复杂性。

二、迭代器模式的实现

场景描述：实现迭代器接口中定义的方法，完成集合的迭代。类图如下：

代码实现如下：

抽象聚集接口实现如下：

/**
 * 抽象聚合类
 */
public interface Aggregate {
    /**
     * 添加元素
     * @param obj
     */
    void add(Object obj);

    /**
     * 删除元素
     * @param obj
     */
    void remove(Object obj);

    /**
     * 迭代器
     * @return
     */
    Iterator iterator();
}

具体聚集角色ConcreteAggregate：

import java.util.ArrayList;
import java.util.List;

/**
 * 具体聚集角色
 */
public class ConcreteAggregate implements Aggregate{
    private List list = new ArrayList<>();
    @Override
    public void add(Object obj) {
        list.add(obj);
    }

    @Override
    public void remove(Object obj) {
        list.remove(obj);
    }

    @Override
    public Iterator iterator() {
        return new ConcreteIterator(list);
    }
}

抽象迭代器角色：

/**
 * 抽象迭代器角色
 */
public interface Iterator {
    /**
     * 获取下一个元素
     * @return
     */
    Object next();

    /**
     * 判断是否有下一个元素
     * @return
     */
    boolean hasNext();
}

具体迭代器角色：

import java.util.ArrayList;
import java.util.List;

public class ConcreteIterator implements Iterator{
    private List list = new ArrayList();
    private int cursor = 0;

    public ConcreteIterator(List list) {
        this.list = list;
    }

    @Override
    public Object next() {
        Object obj = null;
        if(this.hasNext()){
            obj = this.list.get(cursor++);
        }
        return obj;
    }

    @Override
    public boolean hasNext() {
        if(cursor == list.size()){
            return false;
        }
        return true;
    }
}

测试类如下：

public class Client {
    public static void main(String[] args) {
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add("abc");
        aggregate.add("567");
        aggregate.add("Tom");
        aggregate.add("张小航");
        Iterator iterator = aggregate.iterator();
        while(iterator.hasNext()){
            String next = (String) iterator.next();
            System.out.println(next);
        }
    }
}

场景描述：现有两家超市：欢乐购超市和人人佳超市，分别需要将自己的货物信息展示出来。欢乐购超市的货物信息使用数组存放的，而人人佳超市的货物信息是用集合存储的。

货物类：

public class Goods {
    private String name;
    private Double price;

    public Goods(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}

欢乐购超市：

/**
 * 欢乐购超市：货物信息使用数组方式存储
 */
public class HuanLeGou {
    private static final int MAX_SIZE = 100;
    private int index = 0;
    private Goods[] goodsItem;

    public HuanLeGou() {
        goodsItem = new Goods[MAX_SIZE];
        addGoods("牙膏", 4.99);
        addGoods("垃圾桶", 9.99);
        addGoods("毛毯", 56.0);
        addGoods("拖把", 23.9);
    }

    public void addGoods(String name, double price){
        if(index >= MAX_SIZE){
            System.out.println("当前仓库已满，无法存储");
        }else{
            goodsItem[index++] = new Goods(name, price);
        }
    }

    public Iterator creteIterator(){
        return new HuanLeGouIterator(goodsItem);
    }
}

欢乐购超市的迭代器：



import java.util.Iterator;

public class HuanLeGouIterator implements Iterator {
    Goods[] goodsItem;
    int position = 0;
    public HuanLeGouIterator(Goods[] goodsItem) {
        this.goodsItem = goodsItem;
    }

    @Override
    public boolean hasNext() {
        if(position >= goodsItem.length || goodsItem[position] == null){
            return false;
        }
        return true;
    }

    @Override
    public Object next() {
        Goods goods = goodsItem[position++];
        return goods;
    }
}

人人佳超市：



import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
*    人人佳超市：货物信息使用集合存储。
*/
public class RenRenJia {
    private List<Goods> list;

    public RenRenJia() {
        this.list = new ArrayList<>();
        list.add(new Goods("毛巾", 9.99));
        list.add(new Goods("水壶", 35.9));
        list.add(new Goods("作业本", 2.5));
        list.add(new Goods("洗衣液", 19.99));
    }

    public void addGoods(String name, double price){
        list.add(new Goods(name, price));
    }

    public Iterator creteIterator(){
        return new RenRenJiaIterator(list);
    }
}

人人佳超市的迭代器类：

import java.util.Iterator;
import java.util.List;

public class RenRenJiaIterator implements Iterator {
    private List<Goods> list;
    private int position = 0;
    public RenRenJiaIterator(List<Goods> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        if(position >= list.size() || list.get(position) == null){
            return false;
        }
        return true;
    }

    @Override
    public Object next() {
        Goods goods = list.get(position);
        position++;
        return goods;
    }
}

测试类:

public class Client {
    public static void main(String[] args) {
        System.out.println("=======人人佳超市=======");
        RenRenJia renRenJia = new RenRenJia();
        Iterator iterator1 = renRenJia.creteIterator();
        while (iterator1.hasNext()){
            Goods goods = (Goods) iterator1.next();
            System.out.println("名称：" + goods.getName() + "\t\t" + "价格：" + goods.getPrice());
        }
        System.out.println("=======欢乐购超市=======");
        HuanLeGou huanLeGou = new HuanLeGou();
        Iterator iterator2 = huanLeGou.creteIterator();
        while (iterator2.hasNext()){
            Goods goods = (Goods) iterator2.next();
            System.out.println("名称：" + goods.getName() + "\t\t" + "价格：" + goods.getPrice());
        }
    }
}

测试结果：