Java設(shè)計(jì)模式中迭代器模式的示例分析

這篇文章主要介紹Java設(shè)計(jì)模式中迭代器模式的示例分析，文中介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們一定要看完！

介紹

迭代器模式(Iterator Pattern)：提供一種方法來(lái)訪問(wèn)聚合對(duì)象，而不用暴露這個(gè)對(duì)象的內(nèi)部表示，其別名為游標(biāo)(Cursor)。迭代器模式是一種對(duì)象行為型模式。

角色

Iterator（抽象迭代器）：它定義了訪問(wèn)和遍歷元素的接口，聲明了用于遍歷數(shù)據(jù)元素的方法，例如：用于獲取第一個(gè)元素的first()方法，用于訪問(wèn)下一個(gè)元素的next()方法，用于判斷是否還有下一個(gè)元素的hasNext()方法，用于獲取當(dāng)前元素的currentItem()方法等，在具體迭代器中將實(shí)現(xiàn)這些方法。

ConcreteIterator（具體迭代器）：它實(shí)現(xiàn)了抽象迭代器接口，完成對(duì)聚合對(duì)象的遍歷，同時(shí)在具體迭代器中通過(guò)游標(biāo)來(lái)記錄在聚合對(duì)象中所處的當(dāng)前位置，在具體實(shí)現(xiàn)時(shí)，游標(biāo)通常是一個(gè)表示位置的非負(fù)整數(shù)。

Aggregate（抽象聚合類）：它用于存儲(chǔ)和管理元素對(duì)象，聲明一個(gè)createIterator()方法用于創(chuàng)建一個(gè)迭代器對(duì)象，充當(dāng)抽象迭代器工廠角色。

ConcreteAggregate（具體聚合類）：它實(shí)現(xiàn)了在抽象聚合類中聲明的createIterator()方法，該方法返回一個(gè)與該具體聚合類對(duì)應(yīng)的具體迭代器ConcreteIterator實(shí)例。

在迭代器模式中，提供了一個(gè)外部的迭代器來(lái)對(duì)聚合對(duì)象進(jìn)行訪問(wèn)和遍歷，迭代器定義了一個(gè)訪問(wèn)該聚合元素的接口，并且可以跟蹤當(dāng)前遍歷的元素，了解哪些元素已經(jīng)遍歷過(guò)而哪些沒(méi)有。迭代器的引入，將使得對(duì)一個(gè)復(fù)雜聚合對(duì)象的操作變得簡(jiǎn)單。

迭代器模式中的工廠模式

在迭代器模式中應(yīng)用了工廠方法模式，抽象迭代器對(duì)應(yīng)于抽象產(chǎn)品角色，具體迭代器對(duì)應(yīng)于具體產(chǎn)品角色，抽象聚合類對(duì)應(yīng)于抽象工廠角色，具體聚合類對(duì)應(yīng)于具體工廠角色。

學(xué)院遍歷的案例

編寫(xiě)程序展示一個(gè)學(xué)校院系結(jié)構(gòu)：需求是這樣，要在一個(gè)頁(yè)面中展示出學(xué)校的院系 組成， 一個(gè)學(xué)校有多個(gè)學(xué)院，一個(gè)學(xué)院有多個(gè)系。

分析

每一個(gè)學(xué)院都有添加系的功能，如果我們將遍歷的方法hasNext() next()等寫(xiě)入。這將導(dǎo)致聚合類的職責(zé)過(guò)重，它既負(fù)責(zé)存儲(chǔ)和管理數(shù)據(jù)，又負(fù)責(zé)遍歷數(shù)據(jù)，違反了“單一職責(zé)原則”，由于聚合類非常龐大，實(shí)現(xiàn)代碼過(guò)長(zhǎng)，還將給測(cè)試和維護(hù)增加難度。

那么這個(gè)時(shí)候，我們也許會(huì)這樣想，因?yàn)橛卸鄠€(gè)學(xué)院，我們不妨將學(xué)院封裝為接口，但是在這個(gè)接口中充斥著大量方法，不利于子類實(shí)現(xiàn)，違反了“接口隔離原則”。

解決方案

解決方案之一就是將聚合類中負(fù)責(zé)遍歷數(shù)據(jù)的方法提取出來(lái)，封裝到專門(mén)的類中，實(shí)現(xiàn)數(shù)據(jù)存儲(chǔ)和數(shù)據(jù)遍歷分離，無(wú)須暴露聚合類的內(nèi)部屬性即可對(duì)其進(jìn)行操作，而這正是迭代器模式的意圖所在。

基本介紹

• 迭代器模式（Iterator Pattern）是常用的設(shè)計(jì)模式，屬于行為型模式

• 如果我們的集合元素是用不同的方式實(shí)現(xiàn)的，有數(shù)組，還有java的集合類，或者還有其他方式，當(dāng)客戶端要遍歷這些集合元素的時(shí)候就要使用多種遍歷 方式，而且還會(huì)暴露元素的內(nèi)部結(jié)構(gòu)，可以考慮使用迭代器模式解決。

• 迭代器模式，提供一種遍歷集合元素的統(tǒng)一接口，用一致的方法遍歷集合元素， 不需要知道集合對(duì)象的底層表示，即：不暴露其內(nèi)部的結(jié)構(gòu)。

原理類圖

上面案例的類圖

案例實(shí)現(xiàn)代碼

頂層迭代器接口為Java內(nèi)部提供的Iterator接口:

計(jì)算機(jī)學(xué)院迭代器類，負(fù)責(zé)遍歷計(jì)算機(jī)學(xué)院類下面的系集合

public class ComputerCollegeIterator implements Iterator {
    //以數(shù)組的方式存放計(jì)算機(jī)學(xué)院下面的各個(gè)系
    private Department[] departments;
    //當(dāng)前遍歷到的位置
    private  Integer position=0;
    //通過(guò)構(gòu)造器獲得要遍歷的集合
    public ComputerCollegeIterator(Department[] departments)
    {
        this.departments=departments;
    }
    //判斷是否還存在下一個(gè)元素
    @Override
    public boolean hasNext() {
        if(position>departments.length-1||departments[position]==null)
        {
            return false;
        }
        return true;
    }
    //返回下一個(gè)元素
    @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集合中是否還有下一個(gè)元素
    @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() {
    }
}

這里對(duì)應(yīng)的各個(gè)學(xué)院的迭代器類，單獨(dú)負(fù)責(zé)遍歷當(dāng)前學(xué)院下面系集合的邏輯

這里的優(yōu)化措施可以將兩個(gè)迭代器里面重復(fù)內(nèi)容抽取出來(lái)，放到CollegeIterator類里面進(jìn)行默認(rèn)實(shí)現(xiàn)，該類繼承Iterator接口，而上面兩個(gè)學(xué)院迭代器類繼承該默認(rèn)實(shí)現(xiàn)類

迭代器遍歷集合里面存放的元素:

@Data
@AllArgsConstructor
@NoArgsConstructor
//學(xué)院下面的各個(gè)系--也是迭代器需要遍歷的對(duì)象
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);
    //返回一個(gè)迭代器，負(fù)責(zé)遍歷
    Iterator createIterator();
}

計(jì)算機(jī)學(xué)院，管理學(xué)院下面的各個(gè)系

public class ComputerCollege implements College{
    //數(shù)組默認(rèn)大小為10
    private Department[] departments=new Department[10];
    private  Integer numOfDepartment=0;//當(dāng)前數(shù)組中保存的對(duì)象個(gè)數(shù)
    @Override
    public void getName() {
        System.out.println("計(jì)算機(jī)學(xué)院");
    }
   //獲取到對(duì)應(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)建對(duì)應(yīng)的迭代器，并傳入要遍歷的集合給迭代器
    @Override
    public Iterator createIterator() {
        return new ComputerCollegeIterator(departments);
    }
}

信息學(xué)院，負(fù)責(zé)管理下面的各個(gè)系:

//信息學(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集合中是否還有下一個(gè)元素
    @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é)院下面的所有系，需要獲取對(duì)應(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é)

如果需要增加一個(gè)新的具體聚合類，只需增加一個(gè)新的聚合子類和一個(gè)新的具體迭代器類即可,原有類庫(kù)代碼無(wú)須修改，符合“開(kāi)閉原則”；

如果需要為聚合類更換一個(gè)迭代器，只需要增加一個(gè)新的具體迭代器類作為抽象迭代器類的子類，重新實(shí)現(xiàn)遍歷方法，原有迭代器代碼無(wú)須修改，也符合“開(kāi)閉原則”；

但是如果要在迭代器中增加新的方法，則需要修改抽象迭代器源代碼，這將違背“開(kāi)閉原則”。

應(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 源碼中看到了有兩個(gè)迭代器 Itr 和 ListItr，分別實(shí)現(xiàn) Iterator 和 ListIterator 接口；

第一個(gè)當(dāng)然很容易看明白，它跟我們示例的迭代器的區(qū)別是這里是一個(gè)內(nèi)部類，可以直接使用 ArrayList 的數(shù)據(jù)列表；第二個(gè)迭代器是第一次見(jiàn)到， ListIterator 跟 Iterator 有什么區(qū)別呢？

先看 ListIterator 源碼

public interface ListIterator<E> extends Iterator<E> {
    boolean hasNext();
    E next();
    boolean hasPrevious();  // 返回該迭代器關(guān)聯(lián)的集合是否還有上一個(gè)元素
    E previous();           // 返回該迭代器的上一個(gè)元素
    int nextIndex();        // 返回列表中ListIterator所需位置后面元素的索引
    int previousIndex();    // 返回列表中ListIterator所需位置前面元素的索引
    void remove();
    void set(E var1);       // 從列表中將next()或previous()返回的最后一個(gè)元素更改為指定元素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());
    }
}

通過(guò)源碼我們看出：ListIterator 是一個(gè)功能更加強(qiáng)大的迭代器，它繼承于 Iterator 接口，只能用于各種List類型的訪問(wèn)?？梢酝ㄟ^(guò)調(diào)用 listIterator() 方法產(chǎn)生一個(gè)指向List開(kāi)始處的 ListIterator, 還可以調(diào)用 listIterator(n) 方法創(chuàng)建一個(gè)一開(kāi)始就指向列表索引為n的元素處的 ListIterator。

Iterator 和 ListIterator 主要區(qū)別概括如下:

• ListIterator 有 add() 方法，可以向List中添加對(duì)象，而 Iterator 不能

• ListIterator 和 Iterator 都有 hasNext() 和 next() 方法，可以實(shí)現(xiàn)順序向后遍歷，但是ListIterator 有 hasPrevious() 和 previous()方法，可以實(shí)現(xiàn)逆向（順序向前）遍歷。Iterator 就不可以。

• ListIterator 可以定位當(dāng)前的索引位置，nextIndex() 和 previousIndex()可以實(shí)現(xiàn)。Iterator 沒(méi)有此功能。

• 都可實(shí)現(xiàn)刪除對(duì)象，但是 ListIterator 可以實(shí)現(xiàn)對(duì)象的修改，set() 方法可以實(shí)現(xiàn)。Iierator僅能遍歷，不能修改。

角色說(shuō)明

• 內(nèi)部類Itr 充當(dāng)具體實(shí)現(xiàn)迭代器Iterator 的類， 作為ArrayList 內(nèi)部類

• List 就是充當(dāng)了聚合接口，含有一個(gè)iterator() 方法，返回一個(gè)迭代器對(duì)象

• ArrayList 是實(shí)現(xiàn)聚合接口List 的子類，實(shí)現(xiàn)了iterator()

• Iterator 接口系統(tǒng)提供

• 迭代器模式解決了 不同集合(ArrayList ,LinkedList) 統(tǒng)一遍歷問(wèn)題

Mybatis中的迭代器模式

當(dāng)查詢數(shù)據(jù)庫(kù)返回大量的數(shù)據(jù)項(xiàng)時(shí)可以使用游標(biāo) Cursor，利用其中的迭代器可以懶加載數(shù)據(jù)，避免因?yàn)橐淮涡约虞d所有數(shù)據(jù)導(dǎo)致內(nèi)存奔潰，Mybatis 為 Cursor 接口提供了一個(gè)默認(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)

• 提供一個(gè)統(tǒng)一的方法遍歷對(duì)象，客戶不用再考慮聚合的類型，使用一種方法就可以遍歷對(duì)象了。

• 隱藏了聚合的內(nèi)部結(jié)構(gòu)，客戶端要遍歷聚合的時(shí)候只能取到迭代器，而不會(huì)知道聚合的具體組成。

• 提供了一種設(shè)計(jì)思想，就是一個(gè)類應(yīng)該只有一個(gè)引起變化的原因（叫做單一責(zé)任

• 原則）。在聚合類中，我們把迭代器分開(kāi)，就是要把管理對(duì)象集合和遍歷對(duì)象集

• 合的責(zé)任分開(kāi)，這樣一來(lái)集合改變的話，只影響到聚合對(duì)象。而如果遍歷方式改變的話，只影響到了迭代器。

• 當(dāng)要展示一組相似對(duì)象，或者遍歷一組相同對(duì)象時(shí)使用, 適合使用迭代器模式

缺點(diǎn)

• 每個(gè)聚合對(duì)象都要一個(gè)迭代器，會(huì)生成多個(gè)迭代器不好管理類

以上是“Java設(shè)計(jì)模式中迭代器模式的示例分析”這篇文章的所有內(nèi)容，感謝各位的閱讀！希望分享的內(nèi)容對(duì)大家有幫助，更多相關(guān)知識(shí)，歡迎關(guān)注億速云行業(yè)資訊頻道！