Java设计模式学习心得

  • 迭代器模式（iterator pattern）
  • 定义
  • 特点
  • 适用范围
  • 一般写法
  • 迭代器模式测试
  • 测试结果


迭代器模式（iterator pattern）

定义

提供一种方法顺序访问一个聚合（aggregate）对象中的各个元素，而又不暴露其内部的表示。

特点

1.聚合对象实现创建属于自己迭代器接口；
2.迭代器一般有hasNext()、next()、remove()方法。

适用范围

整合不同集合并顺序访问，如array、list、map、set等。

一般写法

假设你想合并两个项目并查看项目的数据，原有代码一个用数组array存储了数据，另一个是用列表list存储了数据，并且两套代码各自依赖各自的存储类型太多，通过改掉其中一套代码的数据存储太难，同时按顺序打印各自代码的数据又暴露出了各自代码的数据存储表示，所以利用迭代器模式输出最舒服，既不暴露自己的数据存储表示，又能按顺序访问不同类型的聚合对象。具体实现如下：
首先先定义两个接口，一个是迭代器的接口，一个是聚合对象需要的创建自己迭代器的接口，后者接口也是为了在想引用具体聚合对象时是通过针对接口编程，而不是针对实现编程，如下所示。

  • 总体接口
public interface Iterator {
    public boolean hasNext();

	// 各自具体聚合类元素按什么顺序被访问都可以各自定义
    public Object next();
}
public interface Aggregate {
	// 各自具体聚合类暴露自己的迭代器
    public Iterator createIterator();
}
  • 两个项目（一个用数组存储数据，另一个用列表存储数据）类实现聚合类接口：
/**
 * 使用数组保存数据
 */
public class ConcreteAggregateOne implements Aggregate {
    // 初始化元素为1，2
    private String[] elements = {"1", "2"};

    @Override
    public Iterator createIterator() {
        return new ConcreteAggregateOneIterator(elements);
    }
}
import java.util.ArrayList;
import java.util.Arrays;

/**
 * 使用列表保存数据
 */
public class ConcreteAggregateTwo implements Aggregate {
    // 初始化元素为3，4
    private ArrayList<String> elements = new ArrayList<>(Arrays.asList("3", "4"));

    @Override
    public Iterator createIterator() {
        return new ConcreteAggregateTwoIterator(elements);
    }
}
  • 迭代器具体实现：
public class ConcreteAggregateOneIterator implements Iterator {
    private String[] elements;
    private int position = 0;

    // 定义构造器输入参数为数组类型
    public ConcreteAggregateOneIterator(String[] elements) {
        this.elements = elements;
    }

    @Override
    public boolean hasNext() {
        return position < elements.length && elements[position] != null;
    }

    @Override
    public Object next() {
        String result = elements[position];
        position = position + 1;
        return result;
    }
}
import java.util.ArrayList;

public class ConcreteAggregateTwoIterator implements Iterator {
    private ArrayList<String> elements;
    private int position;

    // 定义构造器输入参数为列表类型
    public ConcreteAggregateTwoIterator(ArrayList<String> elements) {
        this.elements = elements;
    }

    @Override
    public boolean hasNext() {
        return position < elements.size() && elements.get(position) != null;
    }

    @Override
    public Object next() {
        String result = elements.get(position);
        position = position + 1;
        return result;
    }
}

迭代器模式测试

public class Main {
    public static void main(String[] args) {
        // 写在这里的 Aggregate 就是针对接口编程
        Aggregate concreteAggregateOne = new ConcreteAggregateOne();
        Aggregate concreteAggregateTwo = new ConcreteAggregateTwo();

        Iterator iteratorOne = concreteAggregateOne.createIterator();
        Iterator iteratorTwo = concreteAggregateTwo.createIterator();

        while (iteratorOne.hasNext()) {
            System.out.println(iteratorOne.next());
        }
        while (iteratorTwo.hasNext()) {
            System.out.println(iteratorTwo.next());
        }
    }
}

测试结果

1
2
3
4