迭代器模式——android中使用

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

UML 图例

Iterator: 迭代器接口，定义访问和遍历元素的接口

ConcreateIterator:具体的迭代器实现对象，实现对聚合对象的遍历，并跟踪遍历时的当前位置

Aggreate:聚合对象，定义创建相应迭代器对象的接口。
ConcreteAggregate:具体聚合对象。实现创建相应的迭代器对象。

迭代器的关键思想

迭代器模式的关键思想就是聚合对象的遍历和访问从聚合对象中分离出来，放入单独的迭代器中

示例代码

Aggreate:

public abstract class Aggregate {
    public abstract Interator createInterator();

}

ConcreateIterator

public class ConcreteAggrgate extends Aggregate {
    
    private String[] ss = null;//聚合对象
    
    public ConcreteAggrgate(String[] ss) {
        this.ss = ss;
    }

    @Override
    public Interator createInterator() {
        return new ConcreteIterator(this);
    }
    public Object get(int index) {
        Object retObj = null;
        if(index < ss.length) {
            retObj = ss[index];
        }
        return retObj;
    }
    
    public int size() {
        return ss.length;
    }

}

Iterator：

public interface Interator {
    public void first();
    public void next();
    public boolean isDone();
    public Object currentItem();

}

ConcreteIterator：

public class ConcreteIterator implements Interator {

    private ConcreteAggrgate aggragte;
    private int index = -1;

    public ConcreteIterator(ConcreteAggrgate aggragte) {
        this.aggragte = aggragte;
    }

    @Override
    public void first() {
        // TODO Auto-generated method stub
        index = 0;
    }

    @Override
    public void next() {
        if (index < this.aggragte.size()) {
            index++;
        }
    }

    @Override
    public boolean isDone() {
        if(index == this.aggragte.size()) {
            return true;
        }
        return false;
    }

    @Override
    public Object currentItem() {
        return this.aggragte.get(index);
    }

}

Client

public class Clint {

    public static void main(String[] args) {
        String[] ss = { "张三", "李四", "王二狗", "康熙", "前童" };
        ConcreteAggrgate aggrgate = new ConcreteAggrgate(ss);
        
        Interator interator = aggrgate.createInterator();
        interator.first();
        while(!interator.isDone()) {
            System.out.println(interator.currentItem());
            interator.next();
        }

    }

}

 以上就是迭代器的示例代码

迭代器的模式的优点

1，更好的封装

2，迭代器模式可以让你访问一个聚合对象的内容，而无须暴露该聚合对象的内部表示，从而提高聚合对象的封装性

3，可以以不同的遍历方式来遍历一个聚合对象

4，使用迭代器模式，使得聚合对象的内容和具体的迭代算法分离开。这样就可以通过使用不同的迭代器的实例，不同的遍历方式来遍历一个聚合对象了。

5，迭代器简化了聚合的接口

6，有了迭代器的接口，则聚合本身就不需要在定义这些接口了，从而简化聚合的接口定义。

7，简化客户端调用

8，迭代器为遍历不同的聚合对象提供了一个统一的接口，使得客户端遍历聚合对象的内容变得更简单

9，同一个聚合上可以有多个遍历　　

10，每个迭代器保持它自己的遍历状态，比如前面实现中的迭代索引位置，因此可以对同一个聚合对象同时进行多个遍历

迭代器模式的本质

　　控制访问聚合对象中的元素

何时选用迭代器模式

1，如果你希望提供访问一个聚合对象的内容，但是又不想暴露它的内部实现的时候，可以使用迭代器模式来提供迭代器接口，

从而让客户端只是通过迭代器的接口来访问聚合对象，而无须关心聚合对象的内部实现

2，如果你希望有多种遍历方式可以访问聚合对象，可以使用迭代器模式。

3，如果你希望为遍历不同的聚合对象提供一个统一的接口，可以使用迭代器模式。

Android 中使用迭代器模式demo 

翻页功能

Iterator

public interface MyIterator {
    public boolean hasNext();
    public boolean hasPrevious();
    public Collection next(int num);
    public Collection previous(int num);

}

CollectionIteratorImpl 实现类

public class CollectionIteratorImpl implements MyIterator {

    private DataManager manager;
    private int index = 0;

    public CollectionIteratorImpl(DataManager manager) {
        this.manager = manager;
    }

    @Override
    public boolean hasNext() {
        if (manager != null && index < manager.size()) {
            return true;
        }
        return false;
    }

    @Override
    public boolean hasPrevious() {
        if (manager != null && index > 0) {
            return true;
        }
        return false;
    }

    @Override
    public Collection next(int num) {
        List<Person> col = new ArrayList<>();
        int count = 0;
        while (hasNext() && count < num) {
            col.add(manager.get(index));
            count ++;
            index ++;
        }
        return col;
    }

    @Override
    public Collection previous(int num) {
        List<Person> col = new ArrayList<>();
        int count = 0;
        index = index - num;
        while (hasPrevious() && count < num){
            col.add(manager.get(index));
            count ++;
            index ++;
        }
        return col;
    }
}

DataManager 聚合对象

public class DataManager {

    private List<Person> mDatas = null;

    public DataManager() {
        mDatas = new ArrayList<>();
        for (int i = 0; i < 200; i++) {
            mDatas.add(new Person("姓名"+i,i));
        }
    }


    public int size(){
        return mDatas.size();
    }

    public Person get(int index) {
        Person person = null;
        if(index < size()) {
            person = mDatas.get(index);
        }

        return person;
    }

    public MyIterator createInterator() {
        return new CollectionIteratorImpl(this);
    }

}

Activity 里面使用

public class IteratorActivity extends AppCompatActivity implements DropDownListView.OnListViewListener {


    @Bind(R.id.mDropDownListView)
    DropDownListView mDropDownListView;
    private QuickAdapter mAdapter = null;

    private List<Person> mDatas = null;
    private MyIterator it;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_iterator);
        ButterKnife.bind(this);

        if (mAdapter == null) {
            mAdapter = new QuickAdapter<Person>(this, R.layout.item) {
                @Override
                protected void convert(BaseAdapterHelper helper, Person item) {
                    helper.setText(R.id.container, item.getName() + "     年龄" + item.getAge());
                }
            };
        }

        DataManager dataManager = new DataManager();
27         it = dataManager.createInterator();
        mDatas = (List<Person>) it.next(10);
        mAdapter.addAll(mDatas);

        mDropDownListView.clearFooterView();
        mDropDownListView.setCurrentOffset(mDatas.size());
        mDropDownListView.setOnNextPageListener(this);
        mDropDownListView.setAdapter(mAdapter);
    }

    @Override
    public void onNextPage() {
        mDropDownListView.postDelayed(new Runnable() {
            @Override
            public void run() {
                //每次从迭代器里面拿数据
                List<Person> data =  (List<Person>) it.next(10);
                mAdapter.addAll( data);
                mDropDownListView.setCurrentOffset(data.size());
                mAdapter.notifyDataSetChanged();
            }
        },3000);
    }

    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {

    }
}

基本实现listview 翻页功能

分页基本上有两种实现方式

1，每次需要分页的时候请求网络拉去数据（时间换空间策略）

2，一次性拉去很多条，进行显示（空间换时间策略）

3，每次拉去多条，到了最后一页再从网络上拉去数据（迭代器使用场景，综合上面两种策略）

《研磨设计模式》笔记