Android设计模式---迭代器模式

一. 核心思想

容器对象A提供一个方法xx(其实就是提供一个迭代器), 可以按顺序访问A中各个元素，同时不需暴露A的内部细节.

解释: 要访问A中的各个元素, Iterator是容器.

      Iterator aIterator = new A().getIterator(); //A提供方法getIterator() 获取迭代器
      while (aIterator.hasNext()){ //不断循环迭代
           arrayIterator.next();  //获取A中元素
        }

二. 简单实现

例如: 保存信息的时候.
A员工用list存储数据.
迭代器

public interface IIterator {
    boolean hasNext();    //是否存在下一条记录
    Object next();        //返回当前记录并移到下一条记录
}


public class ListIterator implements IIterator {

    private List<String> mList;
    private int index = 0;//当前索引

    public ListIterator(List<String> list) {
        mList = list;
    }

    @Override
    public boolean hasNext() {//是否存在下一条记录
        return index < mList.size();
    }

    @Override
    public Object next() {//返回当前记录并移到下一条记录
        return mList.get(index++);
    }
}

容器对象

public interface IAggregate {
    IIterator iterator();//返回容器的迭代器
}

public class ListAggregate implements IAggregate {
    private List<String> mList = new ArrayList<>();//内部使用List来存储数据
    public ListAggregate(){
        for (int i = 0; i < 5; i++) {
            mList.add("arrayList>>>" + i);
        }
    }

    @Override
    public IIterator iterator() {//返回迭代器
        return new ListIterator(mList);
    }
}

使用

go(new ListAggregate().iterator());

public void go(IIterator iterator){
        while (iterator.hasNext()){
            Log.d("66",iterator.next()+"");
        }
    }

看起来把代码变复杂了.
假如这个时候来了员工B, 他用的是数组存储. 这个时候用迭代器就方便了.
实现方式如下:

public class ArrayAggregate implements IAggregate {

    private String[] mArrays = new String[5];//数组存储

    public ArrayAggregate(){
        for (int i = 0; i < mArrays.length; i++) {
            mArrays[i] = "array>>" + i;
        }
    }

    @Override
    public IIterator iterator() {//返回迭代器
        return new ArrayIterator(mArrays);
    }
}

public class ArrayIterator implements IIterator {

    private String[] mArrays;
    private int index = 0;//当前索引

    public ArrayIterator(String[] arrays) {
        mArrays = arrays;
    }

    @Override
    public boolean hasNext() {//是否存在下一条记录
        return index < mArrays.length;
    }

    @Override
    public Object next() {//返回当前记录并移到下一条记录
        return mArrays[index++];
    }
}

使用

    go(new ListAggregate().iterator());
    go(new ArrayAggregate().iterator());
    
    public void go(IIterator iterator){
        while (iterator.hasNext()){
            Log.d("66",iterator.next()+"");
        }
    }

好处:调用者不需要关心内部的实现, 只管取数据就行了.
缺点: 会增多类文件, 产生比较多的对象, 消耗内存.

一般高级语言内部都有内置实现, 开发中需要自己实现的情况不多, 了解主要思想就好.