设计模式-迭代器模式（Iterator）

原创 已于 2024-09-03 22:38:44 修改 · 535 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #迭代器模式

于 2024-08-18 21:57:28 首次发布

迭代器模式如何理解，不暴露集合底层表现形式的情况下遍历集合中多有的元素，然而在先生世界中，譬如你出去旅游，你要参观主要旅游景点，可是你到达目的地后，你可能要发较多的时间去找如何到达你目的地的地方，你可能会 找当地导游给你进行内容详细接受，你可以能使用 手机导航，或者使用自由行走 模式。走到哪算到哪。其实这就是由这个景区提供给你的集合迭代器。而这模型在 Java 代码中非常常见。许多框架和库使用它来提供遍历其集合的标准方法。在java中使用的有：

java.util.Iterator（以及 java.util.Scanner）的所有实现。

java.util.Enumeration 的所有实现。

下面举一个例子：、

迭代社交网络配置文件

在此示例中，迭代器模式用于检查远程社交网络集合的社交配置文件，而不向客户端代码公开任何通信详细信息。

public class Profile {
	 private String name;
	    private String email;
	    private Map<String, List<String>> contacts = new HashMap<>();

	    public Profile(String email, String name, String... contacts) {
	        this.email = email;
	        this.name = name;

	        // Parse contact list from a set of "friend:email@gmail.com" pairs.
	        for (String contact : contacts) {
	            String[] parts = contact.split(":");
	            String contactType = "friend", contactEmail;
	            if (parts.length == 1) {
	                contactEmail = parts[0];
	            }
	            else {
	                contactType = parts[0];
	                contactEmail = parts[1];
	            }
	            if (!this.contacts.containsKey(contactType)) {
	                this.contacts.put(contactType, new ArrayList<>());
	            }
	            this.contacts.get(contactType).add(contactEmail);
	        }
	    }

	    public String getEmail() {
	        return email;
	    }

	    public String getName() {
	        return name;
	    }

	    public List<String> getContacts(String contactType) {
	        if (!this.contacts.containsKey(contactType)) {
	            this.contacts.put(contactType, new ArrayList<>());
	        }
	        return contacts.get(contactType);
	    }
}

定义迭代器接口：

public interface ProfileIterator {
	boolean hasNext();
	Profile getNext();
	void reset();
}

public interface SocialNetwork {
	
	 ProfileIterator createFriendsIterator(String profileEmail);

     ProfileIterator createCoworkersIterator(String profileEmail);
}

入口：

public class SocialSpammer {
    public SocialNetwork network;
    public ProfileIterator iterator;

    public SocialSpammer(SocialNetwork network) {
        this.network = network;
    }

    public void sendSpamToFriends(String profileEmail, String message) {
        System.out.println("\nIterating over friends...\n");
        iterator = network.createFriendsIterator(profileEmail);
        while (iterator.hasNext()) {
            Profile profile = iterator.getNext();
            sendMessage(profile.getEmail(), message);
        }
    }

    public void sendSpamToCoworkers(String profileEmail, String message) {
        System.out.println("\nIterating over coworkers...\n");
        iterator = network.createCoworkersIterator(profileEmail);
        while (iterator.hasNext()) {
            Profile profile = iterator.getNext();
            sendMessage(profile.getEmail(), message);
        }
    }

    public void sendMessage(String email, String message) {
        System.out.println("Sent message to: '" + email + "'. Message body: '" + message + "'");
    }
}

实现方式：

public class Facebook implements SocialNetwork {

	 private List<Profile> profiles;

	    public Facebook(List<Profile> cache) {
	        if (cache != null) {
	            this.profiles = cache;
	        } else {
	            this.profiles = new ArrayList<>();
	        }
	    }

	    public Profile requestProfileFromFacebook(String profileEmail) {
	        // Here would be a POST request to one of the Facebook API endpoints.
	        // Instead, we emulates long network connection, which you would expect
	        // in the real life...
	        simulateNetworkLatency();
	        System.out.println("Facebook: Loading profile '" + profileEmail + "' over the network...");

	        // ...and return test data.
	        return findProfile(profileEmail);
	    }

	    public List<String> requestProfileFriendsFromFacebook(String profileEmail, String contactType) {
	        // Here would be a POST request to one of the Facebook API endpoints.
	        // Instead, we emulates long network connection, which you would expect
	        // in the real life...
	        simulateNetworkLatency();
	        System.out.println("Facebook: Loading '" + contactType + "' list of '" + profileEmail + "' over the network...");

	        // ...and return test data.
	        Profile profile = findProfile(profileEmail);
	        if (profile != null) {
	            return profile.getContacts(contactType);
	        }
	        return null;
	    }

	    private Profile findProfile(String profileEmail) {
	        for (Profile profile : profiles) {
	            if (profile.getEmail().equals(profileEmail)) {
	                return profile;
	            }
	        }
	        return null;
	    }

	    private void simulateNetworkLatency() {
	        try {
	            Thread.sleep(2500);
	        } catch (InterruptedException ex) {
	            ex.printStackTrace();
	        }
	    }

	    @Override
	    public ProfileIterator createFriendsIterator(String profileEmail) {
	        return new FacebookIterator(this, "friends", profileEmail);
	    }

	    @Override
	    public ProfileIterator createCoworkersIterator(String profileEmail) {
	        return new FacebookIterator(this, "coworkers", profileEmail);
	    }
}
public class FacebookIterator implements ProfileIterator {
    private Facebook facebook;
    private String type;
    private String email;
    private int currentPosition = 0;
    private List<String> emails = new ArrayList<>();
    private List<Profile> profiles = new ArrayList<>();

    public FacebookIterator(Facebook facebook, String type, String email) {
        this.facebook = facebook;
        this.type = type;
        this.email = email;
    }

    private void lazyLoad() {
        if (emails.size() == 0) {
            List<String> profiles = facebook.requestProfileFriendsFromFacebook(this.email, this.type);
            for (String profile : profiles) {
                this.emails.add(profile);
                this.profiles.add(null);
            }
        }
    }

    @Override
    public boolean hasNext() {
        lazyLoad();
        return currentPosition < emails.size();
    }

    @Override
    public Profile getNext() {
        if (!hasNext()) {
            return null;
        }

        String friendEmail = emails.get(currentPosition);
        Profile friendProfile = profiles.get(currentPosition);
        if (friendProfile == null) {
            friendProfile = facebook.requestProfileFromFacebook(friendEmail);
            profiles.set(currentPosition, friendProfile);
        }
        currentPosition++;
        return friendProfile;
    }

    @Override
    public void reset() {
        currentPosition = 0;
    }
}
public class LinkedIn implements SocialNetwork {

    private List<Profile> contacts;

    public LinkedIn(List<Profile> cache) {
        if (cache != null) {
            this.contacts = cache;
        } else {
            this.contacts = new ArrayList<>();
        }
    }

    public Profile requestContactInfoFromLinkedInAPI(String profileEmail) {
        // Here would be a POST request to one of the LinkedIn API endpoints.
        // Instead, we emulates long network connection, which you would expect
        // in the real life...
        simulateNetworkLatency();
        System.out.println("LinkedIn: Loading profile '" + profileEmail + "' over the network...");

        // ...and return test data.
        return findContact(profileEmail);
    }

    public List<String> requestRelatedContactsFromLinkedInAPI(String profileEmail, String contactType) {
        // Here would be a POST request to one of the LinkedIn API endpoints.
        // Instead, we emulates long network connection, which you would expect
        // in the real life.
        simulateNetworkLatency();
        System.out.println("LinkedIn: Loading '" + contactType + "' list of '" + profileEmail + "' over the network...");

        // ...and return test data.
        Profile profile = findContact(profileEmail);
        if (profile != null) {
            return profile.getContacts(contactType);
        }
        return null;
    }

    private Profile findContact(String profileEmail) {
        for (Profile profile : contacts) {
            if (profile.getEmail().equals(profileEmail)) {
                return profile;
            }
        }
        return null;
    }

    private void simulateNetworkLatency() {
        try {
            Thread.sleep(2500);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public ProfileIterator createFriendsIterator(String profileEmail) {
        return new LinkedInIterator(this, "friends", profileEmail);
    }

    @Override
    public ProfileIterator createCoworkersIterator(String profileEmail) {
        return new LinkedInIterator(this, "coworkers", profileEmail);
    }

}
public class LinkedInIterator implements ProfileIterator {

	private LinkedIn linkedIn;
	private String type;
	private String email;
	private int currentPosition = 0;
	private List<String> emails = new ArrayList<>();
	private List<Profile> contacts = new ArrayList<>();

	public LinkedInIterator(LinkedIn linkedIn, String type, String email) {
		this.linkedIn = linkedIn;
		this.type = type;
		this.email = email;
	}

	private void lazyLoad() {
		if (emails.size() == 0) {
			List<String> profiles = linkedIn.requestRelatedContactsFromLinkedInAPI(this.email, this.type);
			for (String profile : profiles) {
				this.emails.add(profile);
				this.contacts.add(null);
			}
		}
	}

	@Override
	public boolean hasNext() {
		lazyLoad();
		return currentPosition < emails.size();
	}

	@Override
	public Profile getNext() {
		if (!hasNext()) {
			return null;
		}

		String friendEmail = emails.get(currentPosition);
		Profile friendContact = contacts.get(currentPosition);
		if (friendContact == null) {
			friendContact = linkedIn.requestContactInfoFromLinkedInAPI(friendEmail);
			contacts.set(currentPosition, friendContact);
		}
		currentPosition++;
		return friendContact;
	}

	@Override
	public void reset() {
		currentPosition = 0;
	}

}

测试：


	 public static Scanner scanner = new Scanner(System.in);

	    public static void main(String[] args) {
	        System.out.println("Please specify social network to target spam tool (default:Facebook):");
	        System.out.println("1. Facebook");
	        System.out.println("2. LinkedIn");
	        String choice = scanner.nextLine();

	        SocialNetwork network;
	        if (choice.equals("2")) {
	            network = new LinkedIn(createTestProfiles());
	        }
	        else {
	            network = new Facebook(createTestProfiles());
	        }

	        SocialSpammer spammer = new SocialSpammer(network);
	        spammer.sendSpamToFriends("anna.smith@bing.com",
	                "Hey! This is Anna's friend Josh. Can you do me a favor and like this post [link]?");
	        spammer.sendSpamToCoworkers("anna.smith@bing.com",
	                "Hey! This is Anna's boss Jason. Anna told me you would be interested in [link].");
	    }

	    public static List<Profile> createTestProfiles() {
	        List<Profile> data = new ArrayList<Profile>();
	        data.add(new Profile("anna.smith@bing.com", "Anna Smith", "friends:mad_max@ya.com", "friends:catwoman@yahoo.com", "coworkers:sam@amazon.com"));
	        data.add(new Profile("mad_max@ya.com", "Maximilian", "friends:anna.smith@bing.com", "coworkers:sam@amazon.com"));
	        data.add(new Profile("bill@microsoft.eu", "Billie", "coworkers:avanger@ukr.net"));
	        data.add(new Profile("avanger@ukr.net", "John Day", "coworkers:bill@microsoft.eu"));
	        data.add(new Profile("sam@amazon.com", "Sam Kitting", "coworkers:anna.smith@bing.com", "coworkers:mad_max@ya.com", "friends:catwoman@yahoo.com"));
	        data.add(new Profile("catwoman@yahoo.com", "Liza", "friends:anna.smith@bing.com", "friends:sam@amazon.com"));
	        return data;
	    }

测试结果：

Please specify social network to target spam tool (default:Facebook):
1. Facebook
2. LinkedIn
2

Iterating over friends...

LinkedIn: Loading 'friends' list of 'anna.smith@bing.com' over the network...
LinkedIn: Loading profile 'mad_max@ya.com' over the network...
Sent message to: 'mad_max@ya.com'. Message body: 'Hey! This is Anna's friend Josh. Can you do me a favor and like this post [link]?'
LinkedIn: Loading profile 'catwoman@yahoo.com' over the network...
Sent message to: 'catwoman@yahoo.com'. Message body: 'Hey! This is Anna's friend Josh. Can you do me a favor and like this post [link]?'

Iterating over coworkers...

LinkedIn: Loading 'coworkers' list of 'anna.smith@bing.com' over the network...
LinkedIn: Loading profile 'sam@amazon.com' over the network...
Sent message to: 'sam@amazon.com'. Message body: 'Hey! This is Anna's boss Jason. Anna told me you would be interested in [link].'

Java 入门指南：迭代器（Iterator）
热带鱼的技术博客
08-24 3144
迭代器（Iterator） 是一种行为型设计模式，属于设计模式之一，迭代器模式提供了一种方法来顺序访问一个聚合对象（如List、Set等）中各个元素，而不需要暴露该对象的内部表示。
Java Iterator（迭代器）
12-16
Java Iterator（迭代器） Java 集合框架 Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。 Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口， 它扩展了 Iterator 接口。 迭代器 it 的两个基本操作是 next 、hasNext 和 remove。 调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。 调用 it.hasNext() 用于检测集合中是否还有元素。 调用 it.r
Java--Iterator迭代器(集合的遍历)
热门推荐
rbx508780的博客
09-21 2万+
💎本文讲述了iterator，ListItor接口的使用及实现原理，使用迭代器报错ConcurrentModificationException可以来看下原因及解决方案
Java迭代器Iterator
天高任鸟飞
08-11 353
Iterator 迭代器 遍历集合，内部采用指针的方式，来跟踪集合中的元素 用于迭代访问Collection中的元素 HasNext() 判断集合中是否，存在下一个元素 返回值为true、false True，表示存在下一个元素 False，表示到达集合末尾 Next() 取出元素 迭代器的索引 第一次调用之前，索引位于第一个元素之前，不指向任何元素 第一次调用之后，索引...
java迭代器Iterator
szyuan的博客
09-18 160
Java 迭代器Iterator 迭代器Iterator是一种设计模式，可以使序列类型的数据结构的遍历与被遍历的对象分离，我们无需关系该序列的底层结构是什么。只要拿到对象，就可以用迭代器对对象内部的元素进行遍历。如对集合ArrayList和HashSet迭代。 Iterable 实现这个接口的集合对象是可以进行迭代的。IIterable 有一个默认的方法forEach进行遍历操作。 Iterator 迭代器提供迭代的对象，具体如何迭代时这个接口规范的。 Iterator 接口包含三个方法： 1.has
23中设计模式-迭代器(Iterator.html
最新发布
09-03
迭代器模式是一种行为设计模式，它提供了一种方法顺序访问一个集合对象中的各个元素，而又不暴露该对象的内部表示。迭代器模式将遍历集合的责任交给迭代器，而不是集合自身。这样的设计可以简化集合的内部结构，同时...
精选资源
java常用设计模式-迭代器模式
08-28
Java 迭代器模式是一种行为设计模式，它提供了一种访问集合对象元素的方法，而不需要暴露该对象的内部表示。该模式适用于需要遍历集合对象的场景，例如数组、列表、树等。 迭代器模式的主要优点是： 1. 避免了集合...
Java设计模式---迭代器模式（Iterator）介绍
weixin_50055999的博客
06-16 1507
本文介绍了迭代器模式（Iterator）在Java中的应用。迭代器是一种行为型设计模式，提供统一访问集合元素的方式，同时隐藏集合内部实现细节。主要内容包括：1. 迭代器结构：Collection接口继承Iterable，提供iterator()方法；2. 核心方法：hasNext()、next()、remove()；3. 本质：解耦遍历逻辑与数据结构，支持多种遍历方式；4. 组成角色：抽象迭代器、具体迭代器、抽象聚合器、具体聚合器；5. 实际应用：Java集合框架、JDBC ResultSet、文件读取等；
java 迭代器Iterator
_清风明月的博客
03-02 1859
目录 迭代器Iterator 作用： 概念： 迭代器的 常用方法： 迭代器的 使用步骤： 注意事项： 使用详解： 迭代器的 实现原理： 迭代器Iterator 作用： 通用的取出集合中元素的方法。 概念： 迭代器的常用方法： 迭代器的使用步骤： 注意事项： 使用详解： 迭代器的实...
java 迭代器 Iterator
qq_43329585的博客
04-01 440
Iterator迭代器常用于对集合进行迭代操作； 迭代器中提供了四个方法，其中有两个方法决定了我们可以对集合进行遍历操作：next() hasNext()； 一般集合中都提供了如下的方法，通过调用我们可以得到一个迭代器；
java迭代器（Iterator）
ACE_kk的博客
08-05 7128
迭代器是用来遍历容器内所有元素对象的，也是一种常见的设计模式。hasNext() :boolean —— 容器内是否还有可以访问的元素。next() :E —— 返回下一个元素。remove() :void —— 删除当前元素。(Consumer) :void —— JDK 8 中添加的，提供一个 lambda 表达式遍历容器元素。add("Java虚拟机");add("Java中文社群");}};// 遍历if (str.equals("Java中文社群")){}}...
迭代器java_Java中Iterator用法整理
weixin_36309562的博客
02-12 158
一、迭代器简介(Iterator)迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。Java中的Iterator功能比较简单，并且只能单向移动：(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：i...
Java的迭代器—— Iterator
z2431435的博客
03-30 1132
定义 Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。 创建方式 创建一个集合如 ArrayList 或HashSet，ArrayList<String> sites = new ArrayList<String>(); 获取迭代器，Iterator<String> it = sites.iterator(); ArrayList<String> sites = ne
JAVA中的迭代器（Iterator）
计算机小白的奋起
01-23 905
JAVA中的迭代器（Iterator）1.Iterator接口的方法2.使用迭代器（Iterator）遍历集合3.注意 1.Iterator接口的方法 方法名 作用 boolean hasNext() 如果迭代器还有更多的元素，则返回true next() 返回迭代器中的下一个元素 void remove() 从基础集合中删除 iterator() 返回的最后一个元素 2.使用迭代器（Iterator）遍历集合 代码如下： @Test public void te
[Java]迭代器(Iterator)
haoziiy的博客
08-17 354
迭代器(Iterator)是一个对象，它的工作是遍历并选择序列中的对象，它提供了一种访问一个容器(container)对象中的各个元素，而又不必暴露该对象内部细节的方法。通过迭代器，开发人员不需要了解容器底层的结构，就可以实现对容器的遍历。由于创建迭代器的代价小，因此迭代器通常被称为轻量级的容器。迭代器的使用主要有以下三个方面的注意事项： 1）使用容器的iterator()方法返回一个Iterat
迭代器 java_迭代器(iterator)
weixin_35719180的博客
02-21 387
如果我们想遍历数组，这很容易，因为可以用数组的下标跟踪所在的位置，然而在链表中，节点没有这样的下标，怎样才能提供给链表用户类似于数组下标的东西呢？这就是迭代器(iterator)的作用。我们知道添加到链表中的数据(data)，都会包装成一个节点(node)，节点之间通过引用保存了先后关系(pre、next)。但是由于在获取数据时(如getFirst)，返回的直接是数据(data)，数据本身没有其之...
Java:迭代器（Iterator）
荒漠甘泉
06-23 645
Java: 迭代器（Iterator）　　迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。　　Java中的Iterator功能比较简单，并且只能单向移动：　　(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返
Java学习之迭代器Iterator
houjiahui000的博客
07-31 262
所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现Iterator接口的对象。     Iterator对象称作为迭代器，用以方便的对容器内元素的遍历操作，Iterator接口定义了如下方法：         boolean hashNext();            //判断是否有元素没有被遍历     Objectnext();
C#行为模式设计模式详解-迭代器模式实例讲解
总之，文档标题中的“C#面向对象设计模式纵横谈-行为模式（合集）”以及描述中提及的李建忠老师的主讲，传达了文档将深入探讨C#语言中面向对象设计的行为型模式，特别是迭代器模式。该文档意在帮助读者掌握设计模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

树懒_Zz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值