再战设计模式(十三)之行为型-迭代模式

迭代模式

这个模式在工作中经常用,但是我没有没有做过多的了解.在项目中一般我们不需要自己去实现,如果我们实现自己的数据结构的时候可以使用这个模式为我们的数据结构具有可迭代的功能

角色:

iterator(迭代器):接口

他定义了迭代器可具有的功能

aggregate(集合):

类,可以是我们自己的集合类 里面具有集合类自己的迭代器.

concreteIterator

我们自己实现的迭代器,这里我把他写到aggregate中作为子类可以直接获取,在jdk中也是这样的写法

client 调用者

注意:

在图解设计模式中,使用的是aggregate接口(只有一个方法可以返回迭代器对象), 然后具体的类对象 去实现他获取iterator 对象,

而我们是直接在具体的类中做了内部类直接获取.原理是一样的.

类图:

代码:

/**
 * iterator 接口
 * @Created by xiaodao
 */
public interface MyIterator {
    void first();//将游标指向第一个
    Object next(); //指向下一个元素
    boolean hasNext();

    boolean isFirst();
    boolean isLast();

    Object getCurrentObj();
}
/**
 * @Created by xiaodao
 * 聚合类
 */
public class ConcreteMyAggregate {

    private List<Object> list = new ArrayList<>();

    public void add(Object obj){
        list.add(obj);
    }

    public  void remove(Object obj){
        list.remove(obj);
    }
    public MyIterator getIterator(){
        return new ConcreteIterator();
}

    /**
     * 内部类返回聚合类的迭代器...
     */
 private class ConcreteIterator implements  MyIterator{

        private int cursor;

        @Override
        public void first() {
            cursor =0;
        }

        @Override
        public Object next() {
            try {
                return list.get(cursor);
            } finally {
                if(cursor <list.size()){
                    cursor++;
                }
            }
        }

        @Override
        public boolean hasNext() {
            if(cursor <list.size()){
                return true;
            }
            return  false;
        }

        @Override
        public boolean isFirst() {
            return cursor==0? true:false;
        }

        @Override
        public boolean isLast() {
            return cursor ==(list.size()-1)?true:false;
        }

        @Override
        public Object getCurrentObj() {
            Object o = list.get(cursor);
            next();
            return o;
        }
    }

}


/**
 * @Created by xiaodao
 */
public class Client {

    public static void main(String[] args) {
        ConcreteMyAggregate c = new ConcreteMyAggregate();
        c.add("11");
        c.add("2323");
        c.add(1223);

        MyIterator iterator = c.getIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

源码

  private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

在array中也是使用的内部来继承了iterator接口来使用arraylist具有自己的迭代器

总结:

这个类总体来说有点不算难.有个概念就好.

主要记住有个iterator 接口 有个集合 集合里有个方法返回 iterator 的子类,这个子类实现了这个集合的遍历.. 就可以