2. 程式人生 > >Java設計模式——迭代器模式

Java設計模式——迭代器模式

阿新 • • 發佈：2018-11-28

迭代器模式的定義是：
　　提供一種方法順序訪問一個聚合物件中的各個元素，而又不暴露其內部表示
問題：
　　這裡引用《Head First》中的一個示例，如果一個聚合物件（選單）中存在兩種不同的儲存結構（ArrayList & Array），該如何操作？
　　如果是簡單的逐個遍歷，程式的擴充套件性就會很差， 如果再增加新的儲存結構，就需要對程式碼進行大量的修改
解決辦法：
　　可以建立一個物件，將他稱之為迭代器（Iterator），利用它來封裝“遍歷集合內每個物件的過程”，然後迭代器暗中根據容器的不同，使用不同的呼叫方法。
　　
（這裡可以這麼理解，用迭代器去迭代，可以都呼叫next 和hasNext方法，然後在這兩個方法中寫具體的實現，這樣我們如果要是需要新增儲存結構的話，也只需要呼叫這兩個方法，然後在對應的迭代器中去書寫相應的迭代程式碼就可以了）
　　這裡先介紹一下Java中的迭代器，Java中的迭代器位於java.util.Iterator包下，是一個輕量級的物件，建立代價小，主要方法有
　　1 hashNext (判斷當前元素是否存在（不會移動指標)
　　2 next(返回當前元素，並指向下一個元素)

使用迭代器的好處：
　　1 提供了一種簡單的遍歷方式
　　2 支援以不同的方式去遍歷一個聚合物件（ArrayList和Array的遍歷方式不同，但是使用迭代器可以遍歷這兩種儲存結構組成的聚合物件）
　　3 不會暴露內部實現細節
　　4 解耦合
　　5 具有擴充套件性，增加新的聚合類和迭代器都很方便，無需修改原有程式碼
例子程式碼實現：
Menu，提供通用的方法規範：

package spring.design.pattern.iterator;
 
import java.util.Iterator;
 
/**
 * Description:
 *
 * @author 慕容藍
 * @version 1.0
 * @date 2018/11/27 17:09
 */
 

public interface Menu {
  Iterator createIterator();
}

選單（陣列），在這個類裡，它會把資料儲存的資料，交給迭代器進行處理

package spring.design.pattern.iterator;
 
import java.util.Iterator;
 
/**
 * Description:晚餐類.
 *
 * @author 慕容藍
 * @version 1.0
 * @date 2018/11/27 15:05
 */
public class DinerMenu implements Menu{
  static final
 
 int Max_ITEMS = 6;
  int numberOfItems = 0;
  MenuItem[] menuItems;
 
  public DinerMenu() {
    menuItems = new MenuItem[Max_ITEMS];
    AddItem("紅燒肉", "Braised pork", false, 10.5);
    AddItem("番茄炒蛋", "Tomato scrambled eggs", false, 8.5);
  }
 
  public void AddItem(String name, String description, Boolean vegetarian, double price) {
    MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
    if (numberOfItems > Max_ITEMS) {
      throw new RuntimeException("選單已滿");
    } else {
      menuItems[numberOfItems] = menuItem;
      numberOfItems++;
    }
  }
 
  @Override
  public Iterator createIterator(){
    return new DinerMenuIterator(menuItems);
  }
}

選單（集合），同上

package spring.design.pattern.iterator;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Iterator;
 
/**
 * Description:早餐類.
 *
 * @author 慕容藍
 * @version 1.0
 * @date 2018/11/27 14:59
 */
public class PancakeHouseMenu implements Menu{
  ArrayList<MenuItem> menuItems;
 
  public PancakeHouseMenu() {
    menuItems = new ArrayList();
    AddItem("牛奶", "milk", false, 3.0);
    AddItem("麵包", "bread", false, 1.0);
  }
 
  public void AddItem(String name, String description, Boolean vegetarian, double price) {
    MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
    menuItems.add(menuItem);
  }
 
  @Override
  public Iterator createIterator() {
    return menuItems.iterator();
  }
}

陣列&集合中儲存的物件：

package spring.design.pattern.iterator;
 
/**
 * Description:選單類.
 *
 * @author 慕容藍
 * @version 1.0
 * @date 2018/11/27 14:55
 */
public class MenuItem {
  private String name;
  private String description;
  private boolean vegetarin;
  private double price;
 
  public MenuItem(String name, String description, boolean vegetarin, double price) {
    this.name = name;
    this.description = description;
    this.vegetarin = vegetarin;
    this.price = price;
  }
 
  public double getPrice() {
    return price;
  }
 
  public String getName() {
    return name;
  }
 
  public String getDescription() {
    return description;
  }
 
  public boolean isVegetarin() {
    return vegetarin;
  }
}

陣列的迭代器，這裡重寫了迭代器的三個方法hasNext next remove：

package spring.design.pattern.iterator;
 
import java.util.Iterator;
 
/**
 * Description:晚餐選單迭代器.
 *
 * @author 慕容藍
 * @version 1.0
 * @date 2018/11/27 15:23
 */
public class DinerMenuIterator implements Iterator {
 
  /** position記錄當前陣列遍歷的位置 */
  int position = 0;
 
  MenuItem[] items;
 
  public DinerMenuIterator(MenuItem[] items) {
    this.items = items;
  }
 
  @Override
  public boolean hasNext() {
    if (position >= items.length || items[position] == null) {
      return false;
    }
    return true;
  }
 
  @Override
  public Object next() {
    MenuItem menuItem = items[position];
    position = position + 1;
    return menuItem;
  }
 
  @Override
  public void remove() {
    if (position <= 0) {
      throw new IllegalStateException("You can't remove an item you've done at least one next()");
    }
    if (items[position - 1] != null) {
      for (int i = position - 1; i < (items.length - 1); i++) {
        items[i] = items[i + 1];
      }
      items[items.length - 1] = null;
    }
  }
}

服務員類，負責列印資料：

package spring.design.pattern.iterator;

import java.util.Iterator;

/**
* Description:服務員類.
*
* @author muronglan
* @version 1.0
* @date 2018/11/27 15:30
*/
public class Waitress {
 /** init() */
 Menu pancakeHouseMenu ;

 Menu dinerMenu ;

 public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
   this.pancakeHouseMenu = pancakeHouseMenu;
   this.dinerMenu = dinerMenu;
 }

 public void printMenu() {
   Iterator pancakeIterator = pancakeHouseMenu.createIterator();
   Iterator dinerIterator = dinerMenu.createIterator();
   System.out.println("MENU\n --- \nBREAKFAST");
   printMenu(pancakeIterator);
   System.out.println("\nLUNCH");
   printMenu(dinerIterator);
 }

 public void printMenu(Iterator iterator) {
   while (iterator.hasNext()) {
     MenuItem menuItem = (MenuItem) iterator.next();
     System.out.println(menuItem.getName() + ",");
     System.out.println(menuItem.getPrice() + " --- ");
     System.out.println(menuItem.getDescription());
   }
 }
}

測試類，負責展現效果：

package spring.design.pattern.iterator;
 
/**
 * Description:測試類.
 *
 * @author 慕容藍
 * @version 1.0
 * @date 2018/11/27 16:04
 */
public class Test {
  public static void main(String[] args) {
    PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
    DinerMenu dinerMenu = new DinerMenu();
    Waitress waitress = new Waitress(pancakeHouseMenu,dinerMenu);
    waitress.printMenu();
  }
}

找時間補上一張UML圖

在Java程式碼中的集合中，也是使用到了迭代器
Collection介面，繼承了Iteratable介面，該介面中的Iterator方法可以產生一個
Iterator物件：

public interface Collection<E> extends Iterable<E> {…}
/**
 * Performs the given action for each element of the {@code Iterable}
 * until all elements have been processed or the action throws an
 * exception.  Unless otherwise specified by the implementing class,
 * actions are performed in the order of iteration (if an iteration order
 * is specified).  Exceptions thrown by the action are relayed to the
 * caller.
 *
 * @implSpec
 * <p>The default implementation behaves as if:
 * <pre>{@code
 *     for (T t : this)
 *         action.accept(t);
 * }</pre>
 *
 * @param action The action to be performed for each element
 * @throws NullPointerException if the specified action is null
 * @since 1.8
 */

大概意思是對{@code Iterable} 的每個元素執行給定操作，如果產生了異常，異常會被拋給呼叫者
　　
然後使用Iterator就可以對Conllection中的元素進行迭代操作：

public interface Iterator<E> {
    /**
     * 判斷當前元素是否存在（不會移動指標）
     */
    boolean hasNext();
 
    /**
     * 返回當前元素，並指向下一個元素
     */
    E next();
…
}

我們可以通過增強型for迴圈去完成集合中的迭代，也可以自己去呼叫iterator方法，建立一個迭代器

package spring;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * Description:
 *
 * @author 慕容藍
 * @version 1.0
 * @date 2018/11/27 11:52
 */
public class Test {
  public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    for (Integer i : list) {
      System.out.print(i);
    }
  }
}

package spring;

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

/**
* Description:
*
* @author 慕容藍
* @version 1.0
* @date 2018/11/27 11:52
*/
public class Test {
 public static void main(String[] args) {
   List<Integer> list = new ArrayList<>();
   list.add(1);
   list.add(2);
   list.add(3);
   Iterator<Integer> iterator = list.iterator();
   while (iterator.hasNext()){
     System.out.println(iterator.next());
   }
 }
}

相關推薦

重走Java設計模式——迭代器模式（Iterator Pattern）

迭代器模式 定義 提供一種方法順序訪問一個聚合物件中各個元素, 而又無須暴露該物件的內部表示。 模式結構 1.抽象容器：一般是一個介面，提供一個iterator()方法，例如java中的Collection介面，List介面，Set介面等。 2.具體

Java設計模式——迭代器模式

迭代器模式的定義是： 　　提供一種方法順序訪問一個聚合物件中的各個元素，而又不暴露其內部表示 問題： 　　這裡引用《Head First》中的一個示例，如果一個聚合物件（選單）中存在兩種不同的儲存結構（ArrayList & Array），該如何操作？ 　　如果是簡單的逐個遍歷，程式

java設計模式——迭代器模式(Iterator Pattern)

概述：          在軟體開發中，我們經常需要使用聚合物件來儲存一系列資料。聚合物件擁有兩個職責：一是儲存資料；二是遍歷資料。從依賴性來看，前者是聚合物件的基本職責；而後者既是可變化的，又是可分離的。因此，可以將遍歷資料

淺談Java設計模式——迭代器模式(Iterator)

一、概述         給定一個語言，定義它的文法的一種表示，並定義一個直譯器，這個直譯器使用該表示來解釋語言中的句子。 二、使用場景 1.訪問一個聚合物件的內容而無需暴露它的內部表示。  2.支援對聚合物件的多種遍歷。  3.為遍歷不同的聚合結構提供一個統一的介

java設計模式----迭代器模式

定義 在軟體構建過程中，集合物件內部結構常常變化各異，但對於這些集合物件，我們希望在不暴露其內部結構的同時，可以讓外部客戶程式碼透明地訪問其中包含的元素；同時這種“透明遍歷”也為同一種演算法在多種集合物件上進行操作提供了可能。 使用面向物件技術將這種遍歷機制抽象為“迭代器物件”為“應對

JAVA 設計模式 迭代器模式

用途 迭代器模式 (Iterator) 提供一種方法順序訪問一個聚合物件中各個元素，而又不暴露該物件的內部表示。 迭代器模式是一種行為型模式。 結構 圖-迭代器模式結構圖 Iterat

設計模式（Java隨筆）—迭代器模式

迭代器模式（Iterator Pattern）：最常被使用的幾個模式之一，被廣泛的應用到Java API中，如Java集合（Collection）框架中，就有用迭代器來遍歷集合中的元素（在Java開發中，儘量不要自己寫迭代器模，使用Java API提供的Iterator一般就

Java設計模式——迭代器模式（Iterator Pattern）

場景一 描述：週五下午，我正在看技術網站，第六感官發覺有人在身後，扭頭一看，我C，老大站在背後，趕忙站起來， “王經理，你找我？” 我說。 “哦，在看技術呀。有個事情找你談一下，你到我辦公室來一下。” 老大說。 到老大辦公室， “是這樣，剛剛我在看季報，我們每個專案的支出費

Java設計模式--迭代器模式【Iterator Pattern】

          在Java中，因為從JDK 1.2 版本開始增加java.util.Iterator 這個介面，並逐步把Iterator 應用到各個聚集類(Collection)中，我們來看JDK 1.5 的API 幫助檔案，你會看到有一個叫java.util.Iter

設計模式 | 迭代器模式及典型應用

本文的主要內容： 介紹迭代器模式 原始碼分析迭代器模式的典型應用 Java集合中的迭代器模式 Mybatis中的迭代器模式 更多內容可訪問我的個人部落格：laijianfeng.org 關注【小旋鋒】微信公眾號，及時接收博文推送

設計模式 --- 迭代器模式

1.定義 提供一種方法順序訪問一個容器物件中的各個元素，而又不需要暴露該物件的內部表示。   2.使用場景 遍歷一個容器物件   3.簡單實現 大部分容器類都有提供迭代方法 不需要我們自己實現，這裡實現一個通用程式碼。 //迭代器介面 interf

設計模式-迭代器模式(Iterator)

概述 定義 : 提供一種方法, 順序訪問一個集合物件中的各個元素, 而又不暴露該物件的內部表示 型別 : 行為型 適用場景 訪問一個集合物件的內容而無需暴露它的內部表示 為遍歷不同的集合結構提供一個統一的介面 優點 分離了集合物件的遍歷

移動開發之設計模式-迭代器模式(IOS&Android)

資源 完全參照 迭代器模式|菜鳥教程 ,但不包括IOS程式碼 迭代器模式 迭代器模式（Iterator Pattern）是 Java 和 .Net 程式設計環境中非常常用的設計模式。這種模式用於順序訪問集合物件的元素，不需要知道集合物件的底層表示。 迭代器模式屬於行為型模式。

設計模式迭代器模式(IteratorPattern)

核心模組：迭代器角色(定義訪問和遍歷元素的介面)，具體迭代器角色，容器角色，具體容器角色 所有程式碼請訪問：[email protected]:289804201/PatternLearn.git 使用場景：外部物件訪問內部聚合物件； 優點：將儲存資料和

JavaScript設計模式--迭代器模式

迭代器模式是指提供一種方法順序訪問一個聚合物件中的各個元素，而又不需要暴露該物件的內部表示。 JavaScript中的Array.prototype.forEach 一、jQuery中的迭代器

17-Python與設計模式--迭代器模式

一、迭代器與生成器 今天的主角是迭代器模式。在python中，迭代器並不用舉太多的例子，因為python中的迭代器應用實在太多了（不管是python還是其它很多的程式語言中，實際上迭代器都已經納入到了常用的庫或者包中）。而且在當前，也幾乎沒有人專門去開發一個迭代器，而是直接去使用list、string、se

設計模式--迭代器模式與組合方法模式

迭代器模式是將對物件的遍歷封裝成迭代器，對外部隱藏物件遍歷的具體實現。 而組合方法是實現對處於不同層次的同種物件提供一致性的遍歷方法。 首先我們開始討論迭代器模式。 我們在實踐過程中可以遇到這樣的情況，我們需要對用array，ArrayList，Stack  等模式包裝的

設計模式--迭代器模式

迭代器模式（Iterator Pattern） 迭代器模式（Iterator Pattern）是java和.Net程式設計環境中非常常用的設計模式。這種模式用於順序訪問集合物件的元素，不需要知道集合物件的底層實現。大類劃分為行為型模式。 介紹 意圖：提

設計模式-迭代器模式(Iterator Pattern)

模板方法：提供一種方法順序訪問一個聚合物件中的各個元素，而又不暴露其內部的表示。 迭代器模式把在元素之間遊走的責任交給迭代器，而不是聚合物件。這不僅讓聚合的介面和實現變得更簡潔，也可以讓聚合物件更專注在它所應該專注的事情上面(也就是管理物件集合)，而不必去理會遍歷的事情。

PHP設計模式——迭代器模式

宣告：本系列部落格參考資料《大話設計模式》，作者程傑。        迭代器模式：迭代器模式是遍歷集合的成熟模式，迭代器模式的關鍵是將遍歷集合的任務交給一個叫做迭代器的物件，它的工作時遍歷並選擇序列