前言
很早之前，我們的電視調(diào)節(jié)頻道是需要用電視上的按鈕去控制的，那時并沒有遙控器，如果我們想要調(diào)臺，只能一次又一次的擰按鈕。
越來越高級的電視機(jī)相繼出現(xiàn)，現(xiàn)在的電話機(jī)，我們有了電視遙控器，我們使用電視遙控器來調(diào)臺，這個時候，無需直接操作電視。
我們可以將電視機(jī)看成一個存儲電視頻道的集合對象，通過遙控器可以對電視機(jī)中的電視頻道集合進(jìn)行操作，如返回上一個頻道、跳轉(zhuǎn)到下一個頻道或者跳轉(zhuǎn)至指定的頻道。遙控器為我們操作電視頻道帶來很大的方便，用戶并不需要知道這些頻道到底如何存儲在電視機(jī)中。
介紹
迭代器模式(Iterator Pattern)：提供一種方法來訪問聚合對象，而不用暴露這個對象的內(nèi)部表示，其別名為游標(biāo)(Cursor)。迭代器模式是一種對象行為型模式。
角色
Iterator（抽象迭代器）：它定義了訪問和遍歷元素的接口，聲明了用于遍歷數(shù)據(jù)元素的方法，例如：用于獲取第一個元素的first()方法，用于訪問下一個元素的next()方法，用于判斷是否還有下一個元素的hasNext()方法，用于獲取當(dāng)前元素的currentItem()方法等，在具體迭代器中將實(shí)現(xiàn)這些方法。
ConcreteIterator（具體迭代器）：它實(shí)現(xiàn)了抽象迭代器接口，完成對聚合對象的遍歷，同時在具體迭代器中通過游標(biāo)來記錄在聚合對象中所處的當(dāng)前位置，在具體實(shí)現(xiàn)時，游標(biāo)通常是一個表示位置的非負(fù)整數(shù)。
Aggregate（抽象聚合類）：它用于存儲和管理元素對象，聲明一個createIterator()方法用于創(chuàng)建一個迭代器對象，充當(dāng)抽象迭代器工廠角色。
ConcreteAggregate（具體聚合類）：它實(shí)現(xiàn)了在抽象聚合類中聲明的createIterator()方法，該方法返回一個與該具體聚合類對應(yīng)的具體迭代器ConcreteIterator實(shí)例。
在迭代器模式中，提供了一個外部的迭代器來對聚合對象進(jìn)行訪問和遍歷，迭代器定義了一個訪問該聚合元素的接口，并且可以跟蹤當(dāng)前遍歷的元素，了解哪些元素已經(jīng)遍歷過而哪些沒有。迭代器的引入，將使得對一個復(fù)雜聚合對象的操作變得簡單。
迭代器模式中的工廠模式
在迭代器模式中應(yīng)用了工廠方法模式，抽象迭代器對應(yīng)于抽象產(chǎn)品角色，具體迭代器對應(yīng)于具體產(chǎn)品角色，抽象聚合類對應(yīng)于抽象工廠角色，具體聚合類對應(yīng)于具體工廠角色。
學(xué)院遍歷的案例
編寫程序展示一個學(xué)校院系結(jié)構(gòu)：需求是這樣，要在一個頁面中展示出學(xué)校的院系 組成， 一個學(xué)校有多個學(xué)院，一個學(xué)院有多個系。
分析
每一個學(xué)院都有添加系的功能，如果我們將遍歷的方法hasNext() next()等寫入。這將導(dǎo)致聚合類的職責(zé)過重，它既負(fù)責(zé)存儲和管理數(shù)據(jù)，又負(fù)責(zé)遍歷數(shù)據(jù)，違反了“單一職責(zé)原則”，由于聚合類非常龐大，實(shí)現(xiàn)代碼過長，還將給測試和維護(hù)增加難度。
那么這個時候，我們也許會這樣想，因?yàn)橛卸鄠€學(xué)院，我們不妨將學(xué)院封裝為接口，但是在這個接口中充斥著大量方法，不利于子類實(shí)現(xiàn)，違反了“接口隔離原則”。
解決方案
解決方案之一就是將聚合類中負(fù)責(zé)遍歷數(shù)據(jù)的方法提取出來，封裝到專門的類中，實(shí)現(xiàn)數(shù)據(jù)存儲和數(shù)據(jù)遍歷分離，無須暴露聚合類的內(nèi)部屬性即可對其進(jìn)行操作，而這正是迭代器模式的意圖所在。
基本介紹
- 迭代器模式（Iterator Pattern）是常用的設(shè)計模式，屬于行為型模式
- 如果我們的集合元素是用不同的方式實(shí)現(xiàn)的，有數(shù)組，還有java的集合類，或者還有其他方式，當(dāng)客戶端要遍歷這些集合元素的時候就要使用多種遍歷 方式，而且還會暴露元素的內(nèi)部結(jié)構(gòu)，可以考慮使用迭代器模式解決。
- 迭代器模式，提供一種遍歷集合元素的統(tǒng)一接口，用一致的方法遍歷集合元素， 不需要知道集合對象的底層表示，即：不暴露其內(nèi)部的結(jié)構(gòu)。
原理類圖
上面案例的類圖
案例實(shí)現(xiàn)代碼
頂層迭代器接口為Java內(nèi)部提供的Iterator接口:
計算機(jī)學(xué)院迭代器類，負(fù)責(zé)遍歷計算機(jī)學(xué)院類下面的系集合
public class ComputerCollegeIterator implements Iterator {
//以數(shù)組的方式存放計算機(jī)學(xué)院下面的各個系
private Department[] departments;
//當(dāng)前遍歷到的位置
private Integer position=0;
//通過構(gòu)造器獲得要遍歷的集合
public ComputerCollegeIterator(Department[] departments)
{
this.departments=departments;
}
//判斷是否還存在下一個元素
@Override
public boolean hasNext() {
if(position>departments.length-1||departments[position]==null)
{
return false;
}
return true;
}
//返回下一個元素
@Override
public Object next() {
return departments[position++];
}
//刪除的方法默認(rèn)空實(shí)現(xiàn)
@Override
public void remove()
{}
}
信息學(xué)院迭代器類，負(fù)責(zé)遍歷信息學(xué)院下面的系集合
//信息學(xué)院
public class InfoCollegeIterator implements Iterator
{
//以list的方式存放系
private List<Department> departments;
//索引
private Integer index=0;
//構(gòu)造器得到要遍歷的集合
InfoCollegeIterator(List<Department> departments)
{
this.departments=departments;
}
//判斷l(xiāng)ist集合中是否還有下一個元素
@Override
public boolean hasNext() {
if(index>departments.size()-1)
{
return false;
}
return true;
}
@Override
public Object next() {
return departments.get(index++);
}
@Override
public void remove() {
}
}
這里對應(yīng)的各個學(xué)院的迭代器類，單獨(dú)負(fù)責(zé)遍歷當(dāng)前學(xué)院下面系集合的邏輯
這里的優(yōu)化措施可以將兩個迭代器里面重復(fù)內(nèi)容抽取出來，放到CollegeIterator類里面進(jìn)行默認(rèn)實(shí)現(xiàn)，該類繼承Iterator接口，而上面兩個學(xué)院迭代器類繼承該默認(rèn)實(shí)現(xiàn)類
迭代器遍歷集合里面存放的元素:
@Data
@AllArgsConstructor
@NoArgsConstructor
//學(xué)院下面的各個系--也是迭代器需要遍歷的對象
public class Department
{
private String name;//名字
private Integer score;//分?jǐn)?shù)線
}
頂層抽象學(xué)院接口
//抽象學(xué)院接口
public interface College
{
//獲取當(dāng)前系的名字
void getName();
//增加系
void addDepartment(String name,Integer score);
//返回一個迭代器，負(fù)責(zé)遍歷
Iterator createIterator();
}
計算機(jī)學(xué)院，管理學(xué)院下面的各個系
public class ComputerCollege implements College{
//數(shù)組默認(rèn)大小為10
private Department[] departments=new Department[10];
private Integer numOfDepartment=0;//當(dāng)前數(shù)組中保存的對象個數(shù)
@Override
public void getName() {
System.out.println("計算機(jī)學(xué)院");
}
//獲取到對應(yīng)的系集合
public ComputerCollege(Department[] departments)
{
int i=0;
for (Department department : departments) {
this.departments[i++]=department;
}
}
//增加系
@Override
public void addDepartment(String name,Integer score)
{
Department department=new Department(name,score);
departments[numOfDepartment++]=department;
}
//創(chuàng)建對應(yīng)的迭代器，并傳入要遍歷的集合給迭代器
@Override
public Iterator createIterator() {
return new ComputerCollegeIterator(departments);
}
}
信息學(xué)院，負(fù)責(zé)管理下面的各個系:
//信息學(xué)院
public class InfoCollegeIterator implements Iterator
{
//以list的方式存放系
private List<Department> departments;
//索引
private Integer index=0;
InfoCollegeIterator(List<Department> departments)
{
this.departments=departments;
}
//判斷l(xiāng)ist集合中是否還有下一個元素
@Override
public boolean hasNext() {
if(index>departments.size()-1)
{
return false;
}
return true;
}
@Override
public Object next() {
return departments.get(index++);
}
@Override
public void remove() {
}
}
輸出類，主要負(fù)責(zé)輸出功能:
public class OutputImp
{
//學(xué)院集合
private List<College> collegeList;
public OutputImp(List<College> collegeList)
{
this.collegeList=collegeList;
}
//輸出所有學(xué)院，以及學(xué)院下面的所有系
public void printColleges()
{
//獲取到遍歷學(xué)院集合需要用到的迭代器
//list集合實(shí)現(xiàn)了iterator接口
Iterator<College> collegeIterator = collegeList.iterator();
while(collegeIterator.hasNext())
{
College college = collegeIterator.next();
System.out.println("當(dāng)前學(xué)院:");
college.getName();
System.out.println("當(dāng)前學(xué)院下面的系:");
//如果要遍歷當(dāng)前學(xué)院下面的所有系，需要獲取對應(yīng)的迭代器
printDeparts(college.createIterator());
System.out.println("=============================");
}
}
//輸出當(dāng)前學(xué)院的所有系
protected void printDeparts(Iterator iterator)
{
while(iterator.hasNext())
{
Department department=(Department)iterator.next();
System.out.println(department.getName());
}
}
}
客戶端調(diào)用:
public static void main(String[] args) {
List<College> collegeList=new ArrayList<>();
Department[] departments=new Department[3];
departments[0]=new Department("c++",520);
departments[1]=new Department("java",521);
College college=new ComputerCollege(departments);
List<Department> departmentList=new ArrayList<>();
departmentList.add(new Department("密碼學(xué)",520));
College college1=new InfoCollege(departmentList);
collegeList.add(college);
collegeList.add(college1);
OutputImp outputImp=new OutputImp(collegeList);
outputImp.printColleges();
}
案例總結(jié)
如果需要增加一個新的具體聚合類，只需增加一個新的聚合子類和一個新的具體迭代器類即可,原有類庫代碼無須修改，符合“開閉原則”；
如果需要為聚合類更換一個迭代器，只需要增加一個新的具體迭代器類作為抽象迭代器類的子類，重新實(shí)現(xiàn)遍歷方法，原有迭代器代碼無須修改，也符合“開閉原則”；
但是如果要在迭代器中增加新的方法，則需要修改抽象迭代器源代碼，這將違背“開閉原則”。
應(yīng)用實(shí)例
Java集合中的迭代器模式
看 java.util.ArrayList 類
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
transient Object[] elementData; // non-private to simplify nested class access
private int size;
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
public ListIterator<E> listIterator() {
return new ListItr(0);
}
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
public E next() {
//...
}
public E next() {
//...
}
public void remove() {
//...
}
//...
}
private class ListItr extends Itr implements ListIterator<E> {
public boolean hasPrevious() {
return cursor != 0;
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
public E previous() {
//...
}
public void set(E e) {
//...
}
public void add(E e) {
//...
}
//...
}
從 ArrayList 源碼中看到了有兩個迭代器 Itr 和 ListItr，分別實(shí)現(xiàn) Iterator 和 ListIterator 接口；
第一個當(dāng)然很容易看明白，它跟我們示例的迭代器的區(qū)別是這里是一個內(nèi)部類，可以直接使用 ArrayList 的數(shù)據(jù)列表；第二個迭代器是第一次見到， ListIterator 跟 Iterator 有什么區(qū)別呢？
先看 ListIterator 源碼
public interface ListIterator<E> extends Iterator<E> {
boolean hasNext();
E next();
boolean hasPrevious(); // 返回該迭代器關(guān)聯(lián)的集合是否還有上一個元素
E previous(); // 返回該迭代器的上一個元素
int nextIndex(); // 返回列表中ListIterator所需位置后面元素的索引
int previousIndex(); // 返回列表中ListIterator所需位置前面元素的索引
void remove();
void set(E var1); // 從列表中將next()或previous()返回的最后一個元素更改為指定元素e
void add(E var1);
}
接著是 Iterator 的源碼
public interface Iterator<E> {
boolean hasNext();
E next();
default void remove() {
throw new UnsupportedOperationException("remove");
}
// 備注：JAVA8允許接口方法定義默認(rèn)實(shí)現(xiàn)
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
通過源碼我們看出：ListIterator 是一個功能更加強(qiáng)大的迭代器，它繼承于 Iterator 接口，只能用于各種List類型的訪問。可以通過調(diào)用 listIterator() 方法產(chǎn)生一個指向List開始處的 ListIterator, 還可以調(diào)用 listIterator(n) 方法創(chuàng)建一個一開始就指向列表索引為n的元素處的 ListIterator。
Iterator 和 ListIterator 主要區(qū)別概括如下:
- ListIterator 有 add() 方法，可以向List中添加對象，而 Iterator 不能
- ListIterator 和 Iterator 都有 hasNext() 和 next() 方法，可以實(shí)現(xiàn)順序向后遍歷，但是ListIterator 有 hasPrevious() 和 previous()方法，可以實(shí)現(xiàn)逆向（順序向前）遍歷。Iterator 就不可以。
- ListIterator 可以定位當(dāng)前的索引位置，nextIndex() 和 previousIndex()可以實(shí)現(xiàn)。Iterator 沒有此功能。
- 都可實(shí)現(xiàn)刪除對象，但是 ListIterator 可以實(shí)現(xiàn)對象的修改，set() 方法可以實(shí)現(xiàn)。Iierator僅能遍歷，不能修改。
角色說明
- 內(nèi)部類Itr 充當(dāng)具體實(shí)現(xiàn)迭代器Iterator 的類， 作為ArrayList 內(nèi)部類
- List 就是充當(dāng)了聚合接口，含有一個iterator() 方法，返回一個迭代器對象
- ArrayList 是實(shí)現(xiàn)聚合接口List 的子類，實(shí)現(xiàn)了iterator()
- Iterator 接口系統(tǒng)提供
- 迭代器模式解決了 不同集合(ArrayList ,LinkedList) 統(tǒng)一遍歷問題
Mybatis中的迭代器模式
當(dāng)查詢數(shù)據(jù)庫返回大量的數(shù)據(jù)項時可以使用游標(biāo) Cursor，利用其中的迭代器可以懶加載數(shù)據(jù)，避免因?yàn)橐淮涡约虞d所有數(shù)據(jù)導(dǎo)致內(nèi)存奔潰，Mybatis 為 Cursor 接口提供了一個默認(rèn)實(shí)現(xiàn)類 DefaultCursor，代碼如下
public interface Cursor<T> extends Closeable, Iterable<T> {
boolean isOpen();
boolean isConsumed();
int getCurrentIndex();
}
public class DefaultCursor<T> implements Cursor<T> {
private final DefaultResultSetHandler resultSetHandler;
private final ResultMap resultMap;
private final ResultSetWrapper rsw;
private final RowBounds rowBounds;
private final ObjectWrapperResultHandler<T> objectWrapperResultHandler = new ObjectWrapperResultHandler<T>();
// 游標(biāo)迭代器
private final CursorIterator cursorIterator = new CursorIterator();
protected T fetchNextUsingRowBound() {
T result = fetchNextObjectFromDatabase();
while (result != null && indexWithRowBound < rowBounds.getOffset()) {
result = fetchNextObjectFromDatabase();
}
return result;
}
@Override
public Iterator<T> iterator() {
if (iteratorRetrieved) {
throw new IllegalStateException("Cannot open more than one iterator on a Cursor");
}
iteratorRetrieved = true;
return cursorIterator;
}
private class CursorIterator implements Iterator<T> {
T object;
int iteratorIndex = -1;
@Override
public boolean hasNext() {
if (object == null) {
object = fetchNextUsingRowBound();
}
return object != null;
}
@Override
public T next() {
T next = object;
if (next == null) {
next = fetchNextUsingRowBound();
}
if (next != null) {
object = null;
iteratorIndex++;
return next;
}
throw new NoSuchElementException();
}
@Override
public void remove() {
throw new UnsupportedOperationException("Cannot remove element from Cursor");
}
}
// ...
}
游標(biāo)迭代器 CursorIterator 實(shí)現(xiàn)了 java.util.Iterator 迭代器接口，這里的迭代器模式跟 ArrayList 中的迭代器幾乎一樣
優(yōu)點(diǎn)
- 提供一個統(tǒng)一的方法遍歷對象，客戶不用再考慮聚合的類型，使用一種方法就可以遍歷對象了。
- 隱藏了聚合的內(nèi)部結(jié)構(gòu)，客戶端要遍歷聚合的時候只能取到迭代器，而不會知道聚合的具體組成。
- 提供了一種設(shè)計思想，就是一個類應(yīng)該只有一個引起變化的原因（叫做單一責(zé)任
- 原則）。在聚合類中，我們把迭代器分開，就是要把管理對象集合和遍歷對象集
- 合的責(zé)任分開，這樣一來集合改變的話，只影響到聚合對象。而如果遍歷方式改變的話，只影響到了迭代器。
- 當(dāng)要展示一組相似對象，或者遍歷一組相同對象時使用, 適合使用迭代器模式
缺點(diǎn)
- 每個聚合對象都要一個迭代器，會生成多個迭代器不好管理類
總結(jié)
本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關(guān)注服務(wù)器之家的更多內(nèi)容!
原文鏈接：https://blog.csdn.net/m0_53157173/article/details/120183128
