迭代器模式介绍

定义

提供一种方法访问一个容器中的元素,而又不暴露该对象的内部细节.

使用场景

遍历一个聚合对象,但是目前,java中有Collection集合,我们可以直接使用.

优点:

迭代一个对象时候,无需修改源代码.

类图体现

• 抽象容器:一个接口,里面有增删改查的方法名,持有iterator()方法.例如java中的Collection接口.
• 具体容器:实现抽象容器,实现其中方法,以及重写iterator方法.例如ArrayList实现List.
• 抽象迭代器:定义遍历元素所需要的方法,一般有boolean hasNext(), Object next()方法.
• 具体迭代器:实现迭代器中的方法.

代码实现(仿照ArrayList)

1.定义容器Collection,持有抽象迭代器方法Iterator()

public interface Collection<T> {
    
    void  add(T  t);
    
    void remove(T t);
    
    Iterator<T> iterator();
    
    
}

2.定义抽象迭代器Iterator,定义迭代方法

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

3.定义迭代器MyIterator实现

public  class MyIterator<T> implements Iterator<T> {
    
    private List<T> list=new ArrayList<>();
    
    private int cursor=0;
    
    public MyIterator(ArrayList<T> list) {
        // TODO Auto-generated constructor stub
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        // TODO Auto-generated method stub
        return cursor!=list.size();
    }

    @Override
    public T next() {
        // TODO Auto-generated method stub
        T obj=null;
        if(this.hasNext())
        {
            obj=list.get(cursor++);
        }
        return obj;
    }
    
    
}

4.实现具体容器

public class MyArrayList<T> implements Collection<T>{

    public ArrayList<T> list =new ArrayList<>();
    
    @Override
    public void add(T t) {
        // TODO Auto-generated method stub
        list.add(t);
    }

    @Override
    public void remove(T t) {
        // TODO Auto-generated method stub
        list.remove(t);
    }

    @Override
    public Iterator<T> iterator() {
        // TODO Auto-generated method stub
        return new MyIterator<T>(list);
    }
    
    
    

}

5.测试类

public class Test {
    public static void main(String[] args) {
        /**
         * 其实,在collection中的
        ArrayList<String> array=new ArrayList<>();
        array.iterator();
        LinkedList<String> linkedList =new LinkedList<>();
        linkedList.iterator();
        HashSet<String> set=new HashSet<>();
        set.iterator();//内 map.keySet().iterator() d的iterator ,没有实现
        TreeSet<String> set1=new TreeSet<>();
        set1.iterator();*/
        
        
        
        MyArrayList<String> arrayList=new MyArrayList<>();
        arrayList.add("first");
        arrayList.add("second");
        
        Iterator<String> iterator =arrayList.iterator();
        
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

测试结果

first
second

迭代器在java中的体现

Collection集合框架

迭代器Iterator,是结合容器Collection来用的

集合中迭代器的实现

如果想要迭代器, 就要根据容器实现相应的迭代器. 例如:

        ArrayList<String> array=new ArrayList<>();
        array.iterator();
    
        HashSet<String> set=new HashSet<>();
        set.iterator();//内 map.keySet().iterator() d的iterator ,没有实现
        

其中,ArrayList的迭代器实现在 他自己的内部类,而HashSet并没有实现自己的迭代器.

public interface List<E> extends Collection<E> {

    int size();

    boolean isEmpty();

    boolean contains(Object o);

    Iterator<E> iterator();

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    //内部类迭代器
    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;

        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];
        }

.....
}

总结

迭代器模式,java中,已经有了很好的体现和应用.当涉及到对象的遍历等操作,我们直接把他们放到集合中即可.没有必要画蛇添足,浪费资源.

本次学习,有利于理解java语言的设计,加深对java的理解和应用.每一次学习,都有对java的另一种理解.