定义:提供一种方法顺序访问一个聚合对象中各个元素,而又不需暴露该对象的内部表示。

从定义中可以看出,迭代器模式是为了在不暴露该对象内部表示的情况下,提供一种顺序访问聚合对象中元素的方法。这种思想在JAVA集合框架中已经体现的淋漓尽致,而且LZ相信每一个接触JAVA的同学都难免要去触碰。

所以LZ这次先不给出迭代器的类图与标准实现,我们先来看看迭代器模式解决了JAVA集合框架中的哪些问题。

为了更加清晰,LZ斗胆写了几个简单的集合类(向JDK类库的缔造者致敬),我们从这几个简单的集合类出发,去仔细体会下定义的意思,下面是LZ分别写的缩小版的ArrayList、LinkedList和HashSet。

package com.iterator;

public class ArrayList<E> {

    private static final int INCREMENT = 10;

    private E[] array = (E[]) new Object[10];

    private int size;

    public void add(E e){
if (size < array.length) {
array[size++] = e;
}else {
E[] copy = (E[]) new Object[array.length + INCREMENT];
System.arraycopy(array, 0, copy, 0, size);
copy[size++] = e;
array = copy;
}
} public Object[] toArray(){
Object[] copy = new Object[size];
System.arraycopy(array, 0, copy, 0, size);
return copy;
} public int size(){
return size;
}
}
package com.iterator;

public class LinkedList<E> {

    private Entry<E> header = new Entry<E>(null, null, null);
private int size; public LinkedList() {
header.next = header.previous = header;
} public void add(E e){
Entry<E> newEntry = new Entry<E>(e, header, header.next);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
} public int size(){
return size;
} public Object[] toArray(){
Object[] result = new Object[size];
int i = size - 1;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i--] = e.value;
return result;
} private static class Entry<E>{
E value;
Entry<E> previous;
Entry<E> next;
public Entry(E value, Entry<E> previous, Entry<E> next) {
super();
this.value = value;
this.previous = previous;
this.next = next;
}
} }
package com.iterator;

import java.util.HashMap;
import java.util.Map; public class HashSet<E> { private static final Object NULL = new Object(); private Map<E, Object> map = new HashMap<E, Object>(); public void add(E e){
map.put(e, NULL);
} public int size(){
return map.size();
} public Object[] toArray(){
return map.keySet().toArray();
}
}

下面我们看看三个类的遍历方式。

package com.iterator;

public class Main {

    public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<Integer>();
for (int i = 1; i <= 11; i++) {
arrayList.add(i);
}
System.out.println("arrayList size:" + arrayList.size());
Object[] arrayListArray = arrayList.toArray();
for (int i = 0; i < arrayListArray.length; i++) {
System.out.println(arrayListArray[i]);
} System.out.println("----------------------------------------------"); HashSet<Integer> hashSet = new HashSet<Integer>();
for (int i = 1; i <= 11; i++) {
hashSet.add(i);
}
System.out.println("hashSet size:" + hashSet.size());
Object[] setArray = hashSet.toArray();
for (int i = 0; i < setArray.length; i++) {
System.out.println(setArray[i]);
} System.out.println("----------------------------------------------"); LinkedList<Integer> linkedList = new LinkedList<Integer>();
for (int i = 1; i <= 11; i++) {
linkedList.add(i);
}
System.out.println("linkedList size:" + linkedList.size());
Object[] linkedListArray = linkedList.toArray();
for (int i = 0; i < linkedListArray.length; i++) {
System.out.println(linkedListArray[i]);
}
}
}

结果在这里LZ就不贴了,只是简单的输出三次1到11。

各位思考一下,我们这里的遍历是如何做到的。很明显,我们是通过一个通用的方法,toArray做到的。当然,为了迎合面向接口的思想,你可以添加一个接口规定toArray的行为,让三个类去实现它。

但是在这里有一个很大的弊端,不知道各位注意到没有,那就是不论我们的集合类是如何实现的(比如链表,数组,散列),在使用数组遍历集合类的时候,我们其实遍历了两次。

在这三个类中,由于System的arraycopy和set的toArray方法是黑箱子,所以最明显的便是LinkedList的实现,它是先遍历了一遍链表,做出来一个数组,然后当客户端获得到这个数组的时候,则需要再来一次循环,去遍历每一个元素。

为何会是这种情况呢?

很简单,因为我们的集合类本身就不是一个数组,所以自然要多一步从集合类到数组的过渡。哪怕是本身由数组实现的ArrayList,也避免不了多这一步,各位可以试一下在ArrayList中直接返回array属性,结果中会出现一堆null值,而且这样做的话,对于array的改变会直接影响到ArrayList本身,这并不是我们所希望看到的,所以我们返回的只是一个拷贝。

当然,为了解决这个问题,我们并不是没有办法,比如给LinkedList和ArrayList加入get方法,而这个方法有一个参数index,这是我们常用的遍历方法。如此一来,便解决了二次遍历的问题。

但是问题又来了,那就是我们无法给HashSet提供一个根据索引获取元素的方法,由于散列特性的缘故,set中的元素是无序的,或者说顺序是不被保证的。那么这个get方法,在HashSet中便无法提供,因为这里没有我们通俗意义上的索引的概念。

可以看到,上面LZ粗浅的分析,得出一个结论。三个集合类,如果统一提供数组给客户端遍历,那么在遍历过程中会出现重复遍历的现象。而如果消除这种重复遍历,则由于内部数据结构的不同,三个集合类无法做到像提供数组一样,给客户端提供统一的遍历方式。

为了解决上面的问题,迭代器模式就随之出现了。我们先来看看迭代器模式在百度百科中的类图,稍后各位可以自己体会下,迭代器模式是否解决了上面的问题,以及是否提供了额外的一些好处。

看着上面的类图,我们可以分析出来,上面我们所写的ArrayList等三个类都属于ConcreteAggregate的位置。如果我们刚才设计一个数组接口让三个类去实现的话,其实已经和迭代器模式十分相似了。他们的类图会是下面这样的。

                      在上述类图中,我们从面向对象的角度思考,将Object[]当做一个对象对待,我们对比下两个类图,他们其实是非常相似的,其中最大的区别在于,第二个类图当中,没有抽象数组接口这个概念,而在迭代器模式的类图中,是有迭代器接口这个概念的。

                      上述区别最终所造成的结果就是,由于数组是以固定的排列方式存在的,即数组必须是一组连续的内存区域(逻辑上连续),故而以数组为基础的遍历方式只能是按照索引遍历。而迭代器则不限制,我们注意到,在迭代器模式的类图中,具体的迭代器是有一条到具体聚合对象的关联线的,这就意味着迭代器的实现是与具体的聚合对象息息相关的,也就是说迭代器满足了多种迭代方式。

好了,截止到目前,我们前面所讨论的都是为何要使用迭代器模式,或者说迭代器模式解决了哪些问题。我们来稍微总结一下。

1、迭代器模式可以提供统一的迭代方式,这个要归功于Iterator接口。

                      2、迭代器模式可以在对客户透明的前提下,做出各种不同的迭代方式。

                      3、在迭代的时候不需要暴露聚合对象的内部表示,我们只需要认识Iterator即可。

                      4、在第1条的前提下,解决了基于数组的迭代方式中重复遍历的问题。

这里LZ就不再给出迭代器模式的标准代码实现了,如果各位看过LZ的前十几篇设计模式,会发现,LZ其实很多时候是不写标准实现的,一个是因为网上的这种资料很多,很容易找到,LZ不想重复造轮子。还有一个重要的原因是,标准实现总难免给人死板硬套的感觉,很难让人理解,至少LZ个人当时是这种感觉。

这里LZ直接使用迭代器模式,将我们上面的三个集合类稍微优化一下,首先我们应该写一个迭代器接口,它大概会有类图中的那几个方法。为了简单起见,我们直接利用JDK提供的Iterator接口,源码如下。

public interface Iterator<E> {

    boolean hasNext();

    E next();

    void remove();
}

这里迭代器接口已经有了,我们还需要一个可迭代的类接口,在JDK中相当于Iterable接口,它规定了返回一个迭代器的行为,与我们的类图中Array接口类似,只不过那里是toArray方法。下面我们引用JDK中的Iterable接口,非常简单,源码如下。

public interface Iterable<T> {

    Iterator<T> iterator();
}

下面我们就让三个集合类全部提供一个方法,可以返回一个Iterator实例,并且实现Iterable接口。

package com.iterator;

import java.util.Iterator;

public class ArrayList<E> implements Iterable<E>{

    private static final int INCREMENT = 10;

    private E[] array = (E[]) new Object[10];

    private int size;

    public void add(E e) {
if (size < array.length) {
array[size++] = e;
} else {
E[] copy = (E[]) new Object[array.length + INCREMENT];
System.arraycopy(array, 0, copy, 0, size);
copy[size++] = e;
array = copy;
}
} public Object[] toArray() {
Object[] copy = new Object[size];
System.arraycopy(array, 0, copy, 0, size);
return copy;
} public int size() {
return size;
} public Iterator<E> iterator() {
return new Itr();
} private class Itr implements Iterator<E> { int cursor = 0; public boolean hasNext() {
return cursor != size();
} public E next() {
return array[cursor++];
} public void remove() { } }
}
package com.iterator;

import java.util.Iterator;

public class LinkedList<E> implements Iterable<E>{

    private Entry<E> header = new Entry<E>(null, null, null);
private int size; public LinkedList() {
header.next = header.previous = header;
} public void add(E e){
Entry<E> newEntry = new Entry<E>(e, header, header.next);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
} public int size(){
return size;
} public Object[] toArray(){
Object[] result = new Object[size];
int i = size - 1;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i--] = e.value;
return result;
} private static class Entry<E>{
E value;
Entry<E> previous;
Entry<E> next;
public Entry(E value, Entry<E> previous, Entry<E> next) {
super();
this.value = value;
this.previous = previous;
this.next = next;
}
} public Iterator<E> iterator() {
return new Itr();
} private class Itr implements Iterator<E> { Entry<E> current = header; public boolean hasNext() {
return current.previous != header;
} public E next() {
E e = current.previous.value;
current = current.previous;
return e;
} public void remove() { } } }
package com.iterator;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map; public class HashSet<E> implements Iterable<E>{ private static final Object NULL = new Object(); private Map<E, Object> map = new HashMap<E, Object>(7,1); public void add(E e){
map.put(e, NULL);
} public int size(){
return map.size();
} public Object[] toArray(){
return map.keySet().toArray();
} public Iterator<E> iterator() {
return map.keySet().iterator();
} }

这下我们已经将迭代器模式应用到了我们上面的例子当中,至于remove方法,我们为了简短清晰,就不做实现了,而且它并不影响我们理解迭代器模式。现在我们客户端的迭代方式就可以改变一下了。可以像下面这样迭代。

package com.iterator;

import java.util.Iterator;

public class Main {

    public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<Integer>();
for (int i = 1; i <= 11; i++) {
arrayList.add(i);
}
System.out.println("arrayList size:" + arrayList.size());
Iterator<Integer> arrayListIterator = arrayList.iterator();
while(arrayListIterator.hasNext()) {
System.out.println(arrayListIterator.next());
} System.out.println("----------------------------------------------"); HashSet<Integer> hashSet = new HashSet<Integer>();
for (int i = 1; i <= 11; i++) {
hashSet.add(i);
}
System.out.println("hashSet size:" + hashSet.size());
Iterator<Integer> hashSetIterator = hashSet.iterator();
while(hashSetIterator.hasNext()) {
System.out.println(hashSetIterator.next());
} System.out.println("----------------------------------------------"); LinkedList<Integer> linkedList = new LinkedList<Integer>();
for (int i = 1; i <= 11; i++) {
linkedList.add(i);
}
System.out.println("linkedList size:" + linkedList.size());
Iterator<Integer> LinkedListIterator = linkedList.iterator();
while(LinkedListIterator.hasNext()) {
System.out.println(LinkedListIterator.next());
}
}
}

其中输出的结果与第一例是一样的,都是将1到11输出三遍,可以明显的看出,我们刚才的重复遍历问题不见了,而且三个集合类的迭代方法是一样的,而有了这个特点,JAVA在此基础上,给我们提供了foreach语法,所以我们可以写成下面这样。

package com.iterator;

public class Main {

    public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<Integer>();
for (int i = 1; i <= 11; i++) {
arrayList.add(i);
}
System.out.println("arrayList size:" + arrayList.size());
for (Integer i : arrayList) {
System.out.println(i);
} System.out.println("----------------------------------------------"); HashSet<Integer> hashSet = new HashSet<Integer>();
for (int i = 1; i <= 11; i++) {
hashSet.add(i);
}
System.out.println("hashSet size:" + hashSet.size());
for (Integer i : hashSet) {
System.out.println(i);
} System.out.println("----------------------------------------------"); LinkedList<Integer> linkedList = new LinkedList<Integer>();
for (int i = 1; i <= 11; i++) {
linkedList.add(i);
}
System.out.println("linkedList size:" + linkedList.size());
for (Integer i : linkedList) {
System.out.println(i);
}
}
}

这样一来,我们不管你是基于何种数据结构提供的集合类,我们只管foreach遍历,迭代器模式对JAVA集合框架做出的贡献不可谓不大。下面LZ带各位看看现在的类图是如何。

从类图中可以清楚的看出,与迭代器模式的类图是一模一样的,当然,客户端与Iterable的依赖关系有待商议,之前我们已经提到过,JAVA集合框架的工厂方法模式是非透明的处理方式,所以我们很多时候不会使用Iterable,不过这并不影响我们对迭代器模式的理解。

然而迭代器模式所带来的好处已经不言而喻,上面分析的过程中已经提到过,LZ这里不再赘述。

值得注意的是,LZ全部采用的内部类作为各个集合类迭代器的实现,这在LZ之前的文章中已经提到过,当时的解释是说内部类是为了完全杜绝客户端对迭代器实现类的依赖,而进行到现在,我们可以更深一步讨论。

                这里我们的理解是,内部类在这里目的是为了隐藏实现细节,并且如此一来,迭代器的实现类可以自由的使用集合类的各个属性,而不需要集合类提供自己属性访问的接口以及建立二者的关联关系,这种感觉十分像C/C++中的友元类。

                不过缺点也接踵而至,由于具体的集合类与具体的迭代器是绑定的关系,所以这种实现方式在复用的过程中会有很大的限制甚至是不能复用,这个缺点对于C/C++中的友元类来说,是不存在的

十七:迭代器模式详解(foreach的精髓)的更多相关文章

  1. (十七)迭代器模式详解(foreach的精髓)

    作者:zuoxiaolong8810(左潇龙),转载请注明出处,特别说明:本博文来自博主原博客,为保证新博客中博文的完整性,特复制到此留存,如需转载请注明新博客地址即可. 各位好,很久没以LZ的身份和 ...

  2. 设计模式之迭代器模式详解(foreach的精髓)

    作者:zuoxiaolong8810(左潇龙),转载请注明出处,特别说明:本博文来自博主原博客,为保证新博客中博文的完整性,特复制到此留存,如需转载请注明新博客地址即可. 各位好,很久没以LZ的身份和 ...

  3. 设计模式 - 迭代器模式详解及其在ArrayList中的应用

    基本介绍 迭代器模式(Iterator Pattern)是 Java 中使用最多的一种模式,它可以顺序的访问容器中的元素,但不需要知道容器的内部细节 模式结构 Iterator(抽象迭代器):定义遍历 ...

  4. [转载]Java迭代器(iterator详解以及和for循环的区别)

    Java迭代器(iterator详解以及和for循环的区别) 觉得有用的话,欢迎一起讨论相互学习~[Follow] 转载自 https://blog.csdn.net/Jae_Wang/article ...

  5. Extjs MVC开发模式详解

    Extjs MVC开发模式详解   在JS的开发过程中,大规模的JS脚本难以组织和维护,这一直是困扰前端开发人员的头等问题.Extjs为了解决这种问题,在Extjs 4.x版本中引入了MVC开发模式, ...

  6. JavaScript严格模式详解

    转载自阮一峰的博客 Javascript 严格模式详解   作者: 阮一峰 一.概述 除了正常运行模式,ECMAscript 5添加了第二种运行模式:"严格模式"(strict m ...

  7. HTTP协议头部与Keep-Alive模式详解

    HTTP协议头部与Keep-Alive模式详解 .什么是Keep-Alive模式? 我们知道HTTP协议采用“请求-应答”模式,当使用普通模式,即非KeepAlive模式时,每个请求/应答客户和服务器 ...

  8. (" use strict")Javascript 严格模式详解

    Javascript 严格模式详解 转载别人的博客内容,浏览了一遍,没有全部吸收,先保存一下链接 http://www.ruanyifeng.com/blog/2013/01/javascript_s ...

  9. Javascript设计模式之装饰者模式详解篇

    一.前言: 装饰者模式(Decorator Pattern):在不改变原类和继承的情况下动态扩展对象功能,通过包装一个对象来实现一个新的具有原对象相同接口的新的对象. 装饰者模式的特点: 1. 在不改 ...

随机推荐

  1. dart lang 开发环境

    ========================Dart SDK 下载========================Dart SDK 主页: https://dart.dev/toolsDart S ...

  2. 使用Spring访问Mongodb的方法大全——Spring Data MongoDB

    1.概述 Spring Data MongoDB 是Spring框架访问mongodb的神器,借助它可以非常方便的读写mongo库.本文介绍使用Spring Data MongoDB来访问mongod ...

  3. MySQL 部署分布式架构 MyCAT (二)

    安装 MyCAT 安装 java 环境(db1) yum install -y java 下载 Mycat-server-1.6.5-release-20180122220033-linux.tar. ...

  4. ISODATA聚类算法的matlab程序

    ISODATA聚类算法的matlab程序 作者:凯鲁嘎吉 - 博客园 http://www.cnblogs.com/kailugaji/ 参考:Kmeans及ISODATA算法的matlab实现 算法 ...

  5. HTML与CSS学习笔记(5)

    1.文字阴影?(针对文字) text-shadow: 例如 text-shadow: 10px 10px 10px blue;四个值分别是 x y blur color blur表示模糊值,越大越模糊 ...

  6. docker使用,包括有nvidia-docker

    docker run 命令:https://www.runoob.com/docker/docker-run-command.html docker run -it ubuntu:15.10 /bin ...

  7. IntelliJ IDEA 快捷键(七)

    /*方法参数提示*/ ctrl + p /*折叠代码/展开代码*/ ctrl + - / ctrl + + /*快速查找和打开最近使用过的文件*/ ctrl + E /*自动代码片*/ ctrl + ...

  8. luoguP4719 【模板】动态 DP

    题意 我理解的动态DP: 发现DP可以写成矩阵的形式,因此用数据结构维护矩阵乘积. 对于这道题,显然有DP: \(f_{x,0/1}\)表示\(x\)的子树中,x选/不选的最大点独立集. \(f_{x ...

  9. Vue 使用数组和对象控制Class

    直接上代码: <!doctype html> <html lang="en"> <head> <meta charset="UT ...

  10. FineUIPro v6.0.0 大版本更新,快来围观!

    本月末(2019-09-20),我们会发布激动人心的 FineUI v6.0.0 版本,这个版本将带来一系列的重要更新! 在列举新版本特性之前,我们先来回顾下每次发布大版本的关键时间点: v1.0.0 ...