首页 / 设计模式 / HeadFirst设计模式之迭代器模式

HeadFirst设计模式之迭代器模式

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了HeadFirst设计模式之迭代器模式，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12112字，纯文字阅读大概需要18分钟。

内容图文

一、

1.迭代器模式是对遍历集合元素的抽象

2. The Iterator Pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

二、

技术分享

            package
             headfirst.designpatterns.iterator.dinermerger;


            public
            interface
             Iterator {
    
            boolean
             hasNext();
    MenuItem next();
}

             1
            package
             headfirst.designpatterns.iterator.dinermerger;

             2
             3
            public
            class DinerMenuIterator implements Iterator {
 4    MenuItem[] items;
 5int position = 0;
 6 7public DinerMenuIterator(MenuItem[] items) {
 8this.items = items;
 9    }
1011public MenuItem next() {
12         MenuItem menuItem = items[position];
13         position = position + 1;
14return menuItem;
15    }
1617publicboolean hasNext() {
18if (position >= items.length || items[position] == null) {
19returnfalse;
20         } else {
21returntrue;
22        }
23    }
24 }

             1
            package
             headfirst.designpatterns.iterator.dinermerger;

             2
             3
            import
             java.util.ArrayList;

             4
             5
            public
            class PancakeHouseMenuIterator implements Iterator {
 6     ArrayList<MenuItem> items;
 7int position = 0;
 8 9public PancakeHouseMenuIterator(ArrayList<MenuItem> items) {
10this.items = items;
11    }
1213public MenuItem next() {
14         MenuItem item = items.get(position);
15         position = position + 1;
16return item;
17    }
1819publicboolean hasNext() {
20if (position >= items.size()) {
21returnfalse;
22         } else {
23returntrue;
24        }
25    }
26 }

             1
            package
             headfirst.designpatterns.iterator.dinermerger;

             2
             3
            public
            class DinerMenu implements Menu {
 4staticfinalint MAX_ITEMS = 6;
 5int numberOfItems = 0;
 6    MenuItem[] menuItems;
 7 8public DinerMenu() {
 9         menuItems = new MenuItem[MAX_ITEMS];
1011         addItem("Vegetarian BLT",
12             "(Fakin‘) Bacon with lettuce & tomato on whole wheat", true, 2.99);
13         addItem("BLT",
14             "Bacon with lettuce & tomato on whole wheat", false, 2.99);
15         addItem("Soup of the day",
16             "Soup of the day, with a side of potato salad", false, 3.29);
17         addItem("Hotdog",
18             "A hot dog, with saurkraut, relish, onions, topped with cheese",
19false, 3.05);
20         addItem("Steamed Veggies and Brown Rice",
21             "Steamed vegetables over brown rice", true, 3.99);
22         addItem("Pasta",
23             "Spaghetti with Marinara Sauce, and a slice of sourdough bread",
24true, 3.89);
25    }
2627publicvoid addItem(String name, String description, 
28boolean vegetarian, double price) 
29    {
30         MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
31if (numberOfItems >= MAX_ITEMS) {
32             System.err.println("Sorry, menu is full!  Can‘t add item to menu");
33         } else {
34             menuItems[numberOfItems] = menuItem;
35             numberOfItems = numberOfItems + 1;
36        }
37    }
3839public MenuItem[] getMenuItems() {
40return menuItems;
41    }
4243public Iterator createIterator() {
44returnnew DinerMenuIterator(menuItems);
45// To test Alternating menu items, comment out above line,
46// and uncomment the line below.
47//return new AlternatingDinerMenuIterator(menuItems);48    }
4950// other menu methods here51 }

             1
            package
             headfirst.designpatterns.iterator.dinermerger;

             2
             3
            import
             java.util.ArrayList;

             4
             5
            public
            class PancakeHouseMenu implements Menu {
 6     ArrayList<MenuItem> menuItems;
 7 8public PancakeHouseMenu() {
 9         menuItems = new ArrayList<MenuItem>();
1011         addItem("K&B‘s Pancake Breakfast", 
12             "Pancakes with scrambled eggs, and toast", 
13true,
14             2.99);
1516         addItem("Regular Pancake Breakfast", 
17             "Pancakes with fried eggs, sausage", 
18false,
19             2.99);
2021         addItem("Blueberry Pancakes",
22             "Pancakes made with fresh blueberries",
23true,
24             3.49);
2526         addItem("Waffles",
27             "Waffles, with your choice of blueberries or strawberries",
28true,
29             3.59);
30    }
3132publicvoid addItem(String name, String description,
33boolean vegetarian, double price)
34    {
35         MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
36        menuItems.add(menuItem);
37    }
3839public ArrayList<MenuItem> getMenuItems() {
40return menuItems;
41    }
4243public Iterator createIterator() {
44returnnew PancakeHouseMenuIterator(menuItems);
45    }
4647public String toString() {
48return "Objectville Pancake House Menu";
49    }
5051// other menu methods here52 }

            1
            package
             headfirst.designpatterns.iterator.dinermerger;

            2
            3
            public
            interface
             Menu {

            4
            public
             Iterator createIterator();

            5 }

             1
            package
             headfirst.designpatterns.iterator.dinermerger;

             2
             3
            public
            class
             MenuItem {

             4
                String name;

             5
                String description;

             6
            boolean
             vegetarian;

             7
            double
             price;

             8
             9
            public
             MenuItem(String name, 

            10
                                String description, 

            11
            boolean
             vegetarian, 

            12
            double
             price) 

            13
                {

            14
            this.name = name;
15this.description = description;
16this.vegetarian = vegetarian;
17this.price = price;
18    }
1920public String getName() {
21return name;
22    }
2324public String getDescription() {
25return description;
26    }
2728publicdouble getPrice() {
29return price;
30    }
3132publicboolean isVegetarian() {
33return vegetarian;
34    }
35public String toString() {
36return (name + ", $" + price + "\n   " + description);
37    }
38 }

             1
            package
             headfirst.designpatterns.iterator.dinermerger;

             2
             3
            public
            class
             Waitress {

             4
                Menu pancakeHouseMenu;

             5
                Menu dinerMenu;

             6
             7
            public
             Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {

             8
            this.pancakeHouseMenu = pancakeHouseMenu;
 9this.dinerMenu = dinerMenu;
10    }
1112publicvoid printMenu() {
13         Iterator pancakeIterator = pancakeHouseMenu.createIterator();
14         Iterator dinerIterator = dinerMenu.createIterator();
1516         System.out.println("MENU\n----\nBREAKFAST");
17        printMenu(pancakeIterator);
18         System.out.println("\nLUNCH");
19        printMenu(dinerIterator);
2021    }
2223privatevoid printMenu(Iterator iterator) {
24while (iterator.hasNext()) {
25             MenuItem menuItem = iterator.next();
26             System.out.print(menuItem.getName() + ", ");
27             System.out.print(menuItem.getPrice() + " -- ");
28            System.out.println(menuItem.getDescription());
29        }
30    }
3132publicvoid printVegetarianMenu() {
33        printVegetarianMenu(pancakeHouseMenu.createIterator());
34        printVegetarianMenu(dinerMenu.createIterator());
35    }
3637publicboolean isItemVegetarian(String name) {
38         Iterator breakfastIterator = pancakeHouseMenu.createIterator();
39if (isVegetarian(name, breakfastIterator)) {
40returntrue;
41        }
42         Iterator dinnerIterator = dinerMenu.createIterator();
43if (isVegetarian(name, dinnerIterator)) {
44returntrue;
45        }
46returnfalse;
47    }
484950privatevoid printVegetarianMenu(Iterator iterator) {
51while (iterator.hasNext()) {
52             MenuItem menuItem = iterator.next();
53if (menuItem.isVegetarian()) {
54                System.out.print(menuItem.getName());
55                 System.out.println("\t\t" + menuItem.getPrice());
56                 System.out.println("\t" + menuItem.getDescription());
57            }
58        }
59    }
6061privateboolean isVegetarian(String name, Iterator iterator) {
62while (iterator.hasNext()) {
63             MenuItem menuItem = iterator.next();
64if (menuItem.getName().equals(name)) {
65if (menuItem.isVegetarian()) {
66returntrue;
67                }
68            }
69        }
70returnfalse;
71    }
72 }

             1
            package
             headfirst.designpatterns.iterator.dinermerger;

             2
             3
            import java.util.*;
 4 5publicclass MenuTestDrive {
 6publicstaticvoid main(String args[]) {
 7         PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
 8         DinerMenu dinerMenu = new DinerMenu();
 910         Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
1112// Without iterators
13//printMenu();
1415// With iterators16        waitress.printMenu();
1718    }
1920/*21     * Without the Waitress, we need the code below...
22*/23publicstaticvoid printMenu() {
24         PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
25         DinerMenu dinerMenu = new DinerMenu();
2627         ArrayList<MenuItem> breakfastItems = pancakeHouseMenu.getMenuItems();
28         MenuItem[] lunchItems = dinerMenu.getMenuItems();
2930// Hiding implementation31         System.out.println("USING FOR EACH");
32for (MenuItem menuItem : breakfastItems) {
33            System.out.print(menuItem.getName());
34             System.out.println("\t\t" + menuItem.getPrice());
35             System.out.println("\t" + menuItem.getDescription());
36        }
37for (MenuItem menuItem : lunchItems) {
38            System.out.print(menuItem.getName());
39             System.out.println("\t\t" + menuItem.getPrice());
40             System.out.println("\t" + menuItem.getDescription());
41        }
4243// Exposing implementation44         System.out.println("USING FOR LOOPS");
45for (int i = 0; i < breakfastItems.size(); i++) {
46             MenuItem menuItem = (MenuItem)breakfastItems.get(i);
47            System.out.print(menuItem.getName());
48             System.out.println("\t\t" + menuItem.getPrice());
49             System.out.println("\t" + menuItem.getDescription());
50        }
5152for (int i = 0; i < lunchItems.length; i++) {
53             MenuItem menuItem = lunchItems[i];
54            System.out.print(menuItem.getName());
55             System.out.println("\t\t" + menuItem.getPrice());
56             System.out.println("\t" + menuItem.getDescription());
57        }
58    }
59 }

三、用java.util.Iterator

             1
            package
             headfirst.designpatterns.iterator.dinermergercafe;

             2
             3
            import
             java.util.Iterator;

             4
             5
            public
            class DinerMenuIterator implements Iterator<MenuItem> {
 6    MenuItem[] list;
 7int position = 0;
 8 9public DinerMenuIterator(MenuItem[] list) {
10this.list = list;
11    }
1213public MenuItem next() {
14         MenuItem menuItem = list[position];
15         position = position + 1;
16return menuItem;
17    }
1819publicboolean hasNext() {
20if (position >= list.length || list[position] == null) {
21returnfalse;
22         } else {
23returntrue;
24        }
25    }
2627publicvoid remove() {
28if (position <= 0) {
29thrownew IllegalStateException
30                 ("You can‘t remove an item until you‘ve done at least one next()");
31        }
32if (list[position-1] != null) {
33for (int i = position-1; i < (list.length-1); i++) {
34                 list[i] = list[i+1];
35            }
36             list[list.length-1] = null;
37        }
38    }
3940 }

             1
            package
             headfirst.designpatterns.iterator.dinermergercafe;

             2
             3
            import
             java.util.Iterator;

             4
             5
            public
            class DinerMenu implements Menu {
 6staticfinalint MAX_ITEMS = 6;
 7int numberOfItems = 0;
 8    MenuItem[] menuItems;
 910public DinerMenu() {
11         menuItems = new MenuItem[MAX_ITEMS];
1213         addItem("Vegetarian BLT",
14             "(Fakin‘) Bacon with lettuce & tomato on whole wheat", true, 2.99);
15         addItem("BLT",
16             "Bacon with lettuce & tomato on whole wheat", false, 2.99);
17         addItem("Soup of the day",
18             "Soup of the day, with a side of potato salad", false, 3.29);
19         addItem("Hotdog",
20             "A hot dog, with saurkraut, relish, onions, topped with cheese",
21false, 3.05);
22         addItem("Steamed Veggies and Brown Rice",
23             "A medly of steamed vegetables over brown rice", true, 3.99);
24         addItem("Pasta",
25             "Spaghetti with Marinara Sauce, and a slice of sourdough bread",
26true, 3.89);
27    }
2829publicvoid addItem(String name, String description, 
30boolean vegetarian, double price) 
31    {
32         MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
33if (numberOfItems >= MAX_ITEMS) {
34             System.err.println("Sorry, menu is full!  Can‘t add item to menu");
35         } else {
36             menuItems[numberOfItems] = menuItem;
37             numberOfItems = numberOfItems + 1;
38        }
39    }
4041public MenuItem[] getMenuItems() {
42return menuItems;
43    }
4445public Iterator<MenuItem> createIterator() {
46returnnew DinerMenuIterator(menuItems);
47//return new AlternatingDinerMenuIterator(menuItems);48    }
4950// other menu methods here51 }

3.用hashmap

             1
            package
             headfirst.designpatterns.iterator.dinermergercafe;

             2
             3
            import java.util.*;
 4 5publicclass CafeMenu implements Menu {
 6     HashMap<String, MenuItem> menuItems = new HashMap<String, MenuItem>();
 7 8public CafeMenu() {
 9         addItem("Veggie Burger and Air Fries",
10             "Veggie burger on a whole wheat bun, lettuce, tomato, and fries",
11true, 3.99);
12         addItem("Soup of the day",
13             "A cup of the soup of the day, with a side salad",
14false, 3.69);
15         addItem("Burrito",
16             "A large burrito, with whole pinto beans, salsa, guacamole",
17true, 4.29);
18    }
1920publicvoid addItem(String name, String description, 
21boolean vegetarian, double price) 
22    {
23         MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
24        menuItems.put(menuItem.getName(), menuItem);
25    }
2627public Map<String, MenuItem> getItems() {
28return menuItems;
29    }
3031public Iterator<MenuItem> createIterator() {
32return menuItems.values().iterator();
33    }
34 }

原文：http://www.cnblogs.com/shamgod/p/5261420.html

内容总结

以上是互联网集市为您收集整理的HeadFirst设计模式之迭代器模式全部内容，希望文章能够帮你解决HeadFirst设计模式之迭代器模式所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1212730.html

来源：【匿名】

【上一篇】php设计模式--单例模式【下一篇】介绍php设计模式中的工厂模式

更多 ►

【HeadFirst设计模式之迭代器模式】教程文章相关的互联网学习教程文章

HeadFirst设计模式之迭代器模式【代码】【图】

一、1.迭代器模式是对遍历集合元素的抽象2.The Iterator Pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.3.二、1.package headfirst.designpatterns.iterator.dinermerger;publicinterface Iterator {boolean hasNext();MenuItem next(); } 2. 1package headfirst.designpatterns.iterator.dinermerger;2 3publicclass DinerMenuIterator im...

设计模式课程设计模式精讲 18-1 迭代器模式讲解

1　　　　课程讲解1.1　　类型：1.2　　定义：1.3　　适用场景：1.4　　优点：1.5　　缺点：1.6　　与其他设计模式关系： 1　　　　课程讲解1.1　　类型：行为型 1.2　　定义：◆定义：提供一种方法，顺序访问一个集合对象中的各个元素，而又不暴露该对象的内部表示 1.3　　适用场景：◆访问一个集合对象的内容而无需暴露它的内部表示◆为遍历不同的集合结构提供一个统一的接口 1.4　　优点：◆分离了集合对象的遍历行为抽象出了...

23天设计模式之迭代器模式【代码】【图】

23天设计模式之迭代器模式文章简介今天在看Vector类的源码时发现集合基本上都使用到了迭代器模式，去了解了迭代器模式的相关知识，于是就有了这篇文章！在文章中我会拿我们最熟悉的ArrayList类来举例，对应迭代器中的几种角色一一阐释清楚。废话不多说，文章献上。是什么迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。简单来说就是提供了对集合等聚合结构的遍历所有元素的方...

NET设计模式第二部分行为型模式(17)：迭代器模式（Iterator Pattern）【代码】【图】

概述在面向对象的软件设计中，我们经常会遇到一类集合对象，这类集合对象的内部结构可能有着各种各样的实现，但是归结起来，无非有两点是需要我们去关心的：一是集合内部的数据存储结构，二是遍历集合内部的数据。面向对象设计原则中有一条是类的单一职责原则，所以我们要尽可能的去分解这些职责，用不同的类去承担不同的职责。Iterator模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内...

设计模式笔记09-迭代器与组合模式【代码】

//碰撞框 class ColliderBody : public cocos2d::Ref { public:ColliderBody(ContourData *contourData);~ColliderBody();inline ContourData *getContourData() { return _contourData; }#if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT void setColliderFilter(ColliderFilter *filter);ColliderFilter *getColliderFilter(); #endif#if ENABLE_PHYSICS_BOX2D_DETECTvirtual void setB2Fixture(b2Fixture *f...

设计模式--迭代器模式

提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，就应该考虑用迭代器模式。 //定义一个迭代器抽象类 //迭代器抽象类 abstract class Iterator { //用于定义得到开始对象，得到下一个对象、判断是否到结尾、当前对象等抽象方法，统一接口。 public abstract object First(); public abstract object Next...

设计模式之行为型迭代器模式【代码】

在不暴露对象内部结构的同时，可以顺序地访问聚合对象内部的元素。在开发中，迭代器极大简化了代码中的循环语句，使代码结构清晰紧凑。用迭代器去处理一个对象时，只需要提供处理的方法，而不必去关心对象的内部结构，这也解决了对象的使用者与对象内部结构之间的耦合。var Iterator = function(items, container) {// 获取父元素var container = container && document.getElementById(container) || document,// 获取元素items =...

Head First设计模式——迭代器模式【代码】【图】

前言：迭代器模式平时用的不多，因为不管C#还是Java都已经帮我封装了，但是你是否知道平时经常在用的东西本质是怎么回事呢。看完迭代器模式你就知道C# foreach循环是怎么实现的了，我的另一篇C# Foreach循环本质与枚举器就讲解了foreach的本质，其中用到的就是迭代器模式。按照惯例，例子走起。（写了几个小时浏览器崩溃，我看见在自动保存啊，结果没内容，再撸一遍精简点的吧）一、餐馆合并菜单现在有两个餐馆和并，其中一个餐馆...

Java设计模式——迭代器模式【图】

概述网上大部分人说迭代模式的时候，总是以某一种可遍历的对象为例进行介绍。这是可行的，这也是迭代模式的基本原型。当我看到《Head Frist设计模式》中迭代模式的时候，感觉要是能从另一个角度来说明，可能更能够体现迭代模式的威力所在。本文介绍的这种迭代模式，倒是更像是适配器-迭代器模式。希望于你有益~版权说明著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。作者：Coding-Naga发表日期： 2016...

《Head First设计模式》C#实现(四)——迭代器模式【代码】【图】

迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。　　煎饼屋和餐厅合并了！但是有个小问题，虽然两家都同意实现相同的菜单项MenuItem，但是煎饼屋想使用ArrayList储存菜单项，而餐厅则使用数组，为了使女招待能同时访问两家的菜单，我们需要为菜单提供一个统一的访问接口。　　先来看菜单项MenuItem，两家店的实现相同class MenuItem{string name;//名称string description;//描述bool vegeta...

Java设计模式（八）观察者模式迭代器模式

（十五）观察者模式观察者模式，定义对象间一对多关系，一个对象状态发生改变，所有依赖于它的对象都收到通知并且自动更新，观察者与被观察者分开。例如邮件订阅、RSS订阅，如果有更新就会邮件通知你。interface Observers{public void update(); } class Observer1 implements Observers{public void update(){System.out.println("observer1 has received");} } class Observer2 implements Observers{public void update(){Syst...

java23中设计模式之迭代器模式【代码】【图】

package com.bdqn.iterator;publicinterface MyIterator {//将游标指向第一个元素void first();//将游标指向下一个元素void next();//判断存在下一个元素boolean hasNext();boolean iSFirst();boolean iSLast();//获取当前游标指向的对象 Object getCurrentObj();}MyIteratorpackage com.bdqn.iterator;publicinterface MyIterator {//将游标指向第一个元素void first();//将游标指向下一个元素void next();//判断存在下一个元素...

设计模式之迭代器模式【代码】【图】

迭代器模式：提供一个方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。当需要访问一个聚集对象，而不管这些对象是什么都需要遍历的时候，就应该考虑使用迭代器模式。当需要对聚集有多种方式遍历时，可以考虑使用迭代器模式。Iterator迭代器抽象类：publicabstractclass Iterator {publicabstract Object first();publicabstract Object next();publicabstractboolean isDone();publicabstract Object currentI...

Head First 设计模式-模板方法、迭代器

模板方法。　　定义了一个算法的步骤，并允许子类为一个或多个步骤提供实现。　　在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。　原则：不要调用我们，我们会调用你。这和spring的思想一模一样哦。履行这个思想，可以让程序之间低耦合。　　迭代器　　提供一种方法顺序访问一个聚合对象中各个元素，而不又暴露其内部的表示。　　组合模...

PHP设计模式迭代器模式

迭代器模式，在不需要了解内部实现的前提下，遍历一个聚合对象的内部元素。相比于传统的编程模式，迭代器模式可以隐藏遍历元素所需要的操作。AllHacl.php<?phpnamespace Baobab;class AllHacl implements \iterator{protected$ids;protected$index;//当前位置function __construct(){$db = Factory::getDatabase(ha_cl);$result = $db->query(select ID from ha_cl);$this->ids = $result->fetch_all(MYSQLI_ASSOC);}/**　　 * 返回...

首页 / 设计模式 / HeadFirst设计模式之迭代器模式

HeadFirst设计模式之迭代器模式

内容导读

内容图文

内容总结

内容备注

内容手机端

【HeadFirst设计模式之迭代器模式】教程文章相关的互联网学习教程文章

设计模式 - 相关标签

迭代 - 相关标签

设计模式 - 最新教程

设计模式 - 最热教程