23种设计模式学习记录之迭代器模式

想说的话：
在大学的时候曾经学过这23种设计模式，但是那时没啥编程经验，糊里糊涂过了一遍，没多久就忘记了，工作之后将精力主要集中在学习新技术上，比如springboot，cloud，docker，vue。毕业两年后去面试，发现设计模式还是java程序员需要迈过的一道坎，面试的时候问到代理模式和适配器模式有什么区别，你在工作中用到了什么设计模式，怎么用的？答不上来的特别尴尬，所以决定重新学习这几种设计模式，争取在工作中使用上。

本文所有案例代码

码云：https://gitee.com/helloworld6379/designPattern
Github：Github地址

设计模式概述

1 设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通
用解决方案，设计模式（Design pattern）代表了最佳的实践。这些解决方案是众多软件开发人员经过相当长的
一段时间的试验和错误总结出来的。
2 设计模式的本质提高 软件的维护性，通用性和扩展性，并降低软件的复杂度。
3 设计模式并不局限于某种语言，java，php，c++ 都有设计模式.

设计模式类型
设计模式分为三种类型，共 23 种
1 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
2 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
3 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter 模式）、状态模式、策略模式、职责链模式(责任链模式)。

简单介绍

这个就不说了，学过java的都知道。
举个例子：
给省份加上迭代器，迭代每个省份的市。

UML图：

上代码:

/**
* @Description 城市实体类
* @Author: LiuXing
* @Date: 2020/6/8 23:28
*/
public class City {

    private String name;

    public City(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

package com.struggle.pattern.iterator;

import java.util.Iterator;

/**
 * @Description 省份迭代器，其实两个省份可以使用同一个迭代器，这里是为了演示不同迭代器的实现
 * @Author: LiuXing
 * @Date: 2020/6/8 23:28
 */
public class HeNanProvinceIterator implements Iterator {

    private City[] citys;
    private int position = 0; //遍历的位置

    public HeNanProvinceIterator(City[] citys) {
        this.citys = citys;
    }


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

    @Override
    public Object next() {
        City city = citys[position];
        position++;
        return city;
    }
}

package com.struggle.pattern.iterator;

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

/**
 * @Description 省份迭代器，其实两个省份可以使用同一个迭代器，这里是为了演示不同迭代器的实现
 * @Author: LiuXing
 * @Date: 2020/6/8 23:28
 */
public class GuangDongProvinceIterator implements Iterator {

    private List<City> citys;
    private int index = -1;

    public GuangDongProvinceIterator(List<City> citys) {
        this.citys = citys;
    }


    @Override
    public boolean hasNext() {
        if (index >= citys.size() - 1)
            return false;
        else {
            index++;
            return true;
        }
    }

    @Override
    public Object next() {
        return citys.get(index);
    }
}

package com.struggle.pattern.iterator;

import java.util.Iterator;
/**
* @Description 省份接口
* @Author: LiuXing
* @Date: 2020/6/8 23:28
*/
public interface Province {

    String getName();
    //增加系的方法
    void addCity(String name);
    //返回一个迭代器,遍历
    Iterator createIterator();
}

package com.struggle.pattern.iterator;

import java.util.Iterator;
/**
* @Description 具体省份
* @Author: LiuXing
* @Date: 2020/6/8 23:28
*/
public class HeNanProvince implements Province{

    private  City [] citys;
    private int citysize = 0;

    public HeNanProvince(){
        citys = new City[5];
        addCity("郑州");
        addCity("洛阳");
        addCity("南阳");
    }

    @Override
    public String getName() {
        return "河南省";
    }

    @Override
    public void addCity(String name) {
        City city = new City(name);
        citys[citysize++] = city;
    }

    @Override
    public Iterator createIterator() {
        return new HeNanProvinceIterator(citys);
    }
}

package com.struggle.pattern.iterator;

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

/**
 * @Description 具体省份
 * @Author: LiuXing
 * @Date: 2020/6/8 23:28
 */
public class GunangDongProvince implements Province {

    private List<City> citys;

    public GunangDongProvince() {
        citys = new ArrayList<>();
        addCity("广州");
        addCity("深圳");
        addCity("东莞");
    }

    @Override
    public String getName() {
        return "广东省";
    }

    @Override
    public void addCity(String name) {
        City city = new City(name);
        citys.add(city);
    }

    @Override
    public Iterator createIterator() {
        return new GuangDongProvinceIterator(citys);
    }
}

package com.struggle.pattern.iterator;

import java.util.Iterator;
import java.util.List;
/**
* @Description 封装迭代器
* @Author: LiuXing
* @Date: 2020/6/8 23:28
*/
public class OutPutImpl {
    private List<Province> provinces;

    public OutPutImpl(List<Province> provinces){
        this.provinces = provinces;
    }

    public void print(){
        Iterator<Province> iterator = provinces.iterator();
        while (iterator.hasNext()){
            Province province = iterator.next();
            System.out.println("===" + ""+province.getName()+"===");
            printCity(province.createIterator());
        }
    }

    public void printCity(Iterator iterator){
        while (iterator.hasNext()){
            City city = (City)iterator.next();
            System.out.println(city.getName());
        }
    }
}

package com.struggle.pattern.iterator;

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

/**
 * @Description 迭代器模式测试
 * @Author: LiuXing
 * @Date: 2020/5/28 21:32
 */
public class IteratorTest {

    public static void main(String[] args) {
      List<Province> provinces = new ArrayList<>();

        HeNanProvince heNanProvince = new HeNanProvince();
        GunangDongProvince gunangDongProvince = new GunangDongProvince();
        provinces.add(heNanProvince);
        provinces.add(gunangDongProvince);
        OutPutImpl outPut = new OutPutImpl(provinces);
        outPut.print();
    }
}

提供了一种设计思想，就是一个类应该只有一个引起变化的原因（叫做单一责任原则）。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。 而如果遍历方式改变的话，只影响到了迭代器。