迭代器模式小试

迭代器是行为型设计模式的一种，是一种非常简单的设计模式。

转载请注明出处 http://www.cnblogs.com/zrtqsk/p/3716173.html，谢谢！

一、介绍

　　先来看一下《研磨设计模式》的定义——提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。

　　迭代器模式的本质是——控制访问聚合对象中的元素

　　Java中有的聚合对象主要是Collection类、Map类的各子类对象。同样的，数组也算一种聚合对象。迭代器模式就是希望从外部用同一种方式去访问不同的聚合对象。这个怎么做呢？

　　说白了，就是创建一个迭代类，持有聚合对象，并且提供迭代这个聚合对象的方法。这个迭代类怎么得到呢？让原本的聚合对象增加一个方法，可以用来返回一个迭代对象，返回时，将自身传递给这个迭代对象。我们得到了这个迭代对象，就可以轻松的在外部访问这个聚合对象了。

二、我的实现

1、假设我们本身有一个包含简单功能的聚合类MyList，如下：

public class MyList<T> {

    private Object[] elements;
    //容量
    private int capacity = 10;
    //当前大小
    private int size = 0;
    
    //指定容量的构造方法
    public MyList(int capacity){
        this.capacity = capacity;
        elements = new Object[10];
    }
    
    //默认构造方法
    public MyList(){
        this(10);
    }
    
    public int size(){
        return size;
    }
    
    public T get(int i){
        if(i > capacity){
            System.out.println("List数组越界");
            return null;
        }else {
            return (T) elements[i];
        }
    }
    
    public void add(T obj){
        if(size >= capacity){
            //扩容
        }else {
            elements[size ++] = obj;
        }
    }
}

2、测试一下：

public class Test {

    public static void main(String[] args)
    {
        MyList<Apple> list = new MyList<Apple>();
        list.add(new Apple("a"));
        list.add(new Apple("b"));
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(3));
    }
}

class Apple{
    private String name;
    
    public Apple(String name){
        this.name = name;
    }
    
    public String toString(){
        return "Apple:" + name;
    }
    
}

3、结果如下：

Apple:a
Apple:b
List数组越界
null

可见功能正常。

4、我们需要从外部访问这个聚合对象，该怎么做呢？

如前面说的，写一个简单的访问数据的接口，包含简单的迭代聚合对象的功能如下：

public interface Iterator<T> {
    
    public T next();
    
    public boolean hasNext();
}

5、简单的实现类；

public class IteratorImpl<T> implements Iterator<T> {

    private int index = 0;
    MyList list = null;
    public IteratorImpl(MyList list){
        this.list = list;
    }

    @Override
    public T next()
    {
        return (T) list.get(index++);
    }

    @Override
    public boolean hasNext()
    {
        boolean flag = false;
        if(list.get(index) != null){
            flag = true;
        }
        return flag;
    } 
}

6、构建一个简单的抽象类AbstractList，而实际上List的大部分方法都可以放到这个抽象类来，这里为了演示方便，如下：

public abstract class AbstractList {

    public abstract Iterator iterator();
}

7、刚才的MyList继承这个抽象类，其实现方法如下：

@Override
    public Iterator iterator()
    {
        return new IteratorImpl(this);
    }

非常简单！

8、下面我们就是测试，测试类比之前改变一点点，如下；

public class Test {

    public static void main(String[] args)
    {
        MyList<Apple> list = new MyList<Apple>();
        list.add(new Apple("a"));
        list.add(new Apple("b"));
//        System.out.println(list.get(0));
//        System.out.println(list.get(1));
//        System.out.println(list.get(3));
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

9，结果如下：

Apple:a
Apple:b

提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。这就是迭代器模式。

三、Java的迭代器

　　通常而言，我们遍历一个聚合对象除了使用Iterator外，还有一种更简便的方法，那就是用简易的for循环——for(Type t : Collection)。但是当我们用这个方式去访问上文我自定义的聚合对象MyList的时候，发现编译错误。错误提示说，因为我们没有实现java.lang.Iterable接口。　　这个接口位于java.lang包下，意味着我们不用额外导包了。我们来看一下这个接口的源代码：

package java.lang;

import java.util.Iterator;

public interface Iterable<T> {

    Iterator<T> iterator();
}

可见，这个接口只有一个方法，用来返回一个java.util.Iterator接口对象。相当于我们刚才的抽象类。

　　Java的迭代器实现主要就是围绕着这两个接口，我们来看一下java.util.Iterator的源代码

package java.util;

public interface Iterator<E> {

    boolean hasNext();

    E next();

    void remove();
}

可以看到，这个接口是非常简单的。跟上面我自定义的Iterator相比，只是多了一个void remove()方法。

　　下面我们将上面的例子改为Java的迭代器实现。通常而言，由于一个Iterator的实现类是对应一个聚合对象的。为了提高内聚性，我们应该将Iterator实现类作为聚合对象的内部类。而JDK也是这么做的。如下：

import java.util.Iterator;

//实现Iterable接口
public class MyList<T> implements Iterable<T>{

    private Object[] elements;
    // 容量
    private int capacity = 10;
    // 当前大小
    private int size = 0;

    // 指定容量的构造方法
    public MyList(int capacity)
    {
        this.capacity = capacity;
        elements = new Object[10];
    }

    // 默认构造方法
    public MyList()
    {
        this(10);
    }

    public int size()
    {
        return size;
    }

    public T get(int i)
    {
        if (i > capacity)
        {
            System.out.println("List数组越界");
            return null;
        }
        else
        {
            return (T) elements[i];
        }
    }

    public void add(T obj)
    {
        if (size >= capacity)
        {
            // 扩容
        }
        else
        {
            elements[size++] = obj;
        }
    }

    //返回java.util.Iterator对象
    @Override
    public Iterator iterator()
    {
        return new IteratorImpl(this);
    }

    //内部类
    class IteratorImpl<T> implements Iterator<T> {

        private int index = 0;
        MyList list = null;

        public IteratorImpl(MyList list)
        {
            this.list = list;
        }

        @Override
        public T next()
        {
            return (T) list.get(index++);
        }

        @Override
        public boolean hasNext()
        {
            boolean flag = false;
            if (list.get(index) != null)
            {
                flag = true;
            }
            return flag;
        }

        @Override
        public void remove()
        {
            
        }
    }
}

同时，我们还可以使用简易for循环迭代这个聚合对象，如下：

public class Test {

    public static void main(String[] args)
    {
        MyList<Apple> list = new MyList<Apple>();
        list.add(new Apple("a"));
        list.add(new Apple("b"));
//        System.out.println(list.get(0));
//        System.out.println(list.get(1));
//        System.out.println(list.get(3));
        Iterator it = list.iterator();
        for(Apple a : list ){
            System.out.println(a);
        }
    }
}

结果与之前没有什么不同。