迭代器模式

简介: 迭代器模式介绍定义提供一种方法访问一个容器中的元素,而又不暴露该对象的内部细节.使用场景遍历一个聚合对象,但是目前,java中有Collection集合,我们可以直接使用.

迭代器模式介绍

定义

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

使用场景

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

优点:

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

类图体现

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

代码实现(仿照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来用的

img_e9e5917de8c11c79f91a9466df70d921.png

集合中迭代器的实现

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

        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的另一种理解.

目录
相关文章
|
3月前
|
设计模式 Java 数据挖掘
聊聊Java设计模式-迭代器模式
迭代器(Iterator)模式,也叫做游标(Cursor)模式。我们知道,在Java 容器中,为了提高容器遍历的方便性,我们利用迭代器把遍历逻辑从不同类型的集合类中抽取出来,从而避免向外部暴露集合容器的内部结构。
44 0
聊聊Java设计模式-迭代器模式
|
4月前
|
设计模式 uml C++
行为型 迭代器模式
行为型 迭代器模式
20 0
|
6月前
|
设计模式 存储 算法
设计模式~迭代器模式(Iterator)-20
迭代器模式(Iterator Pattern)是Java和.Net编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素,不需要知道集合对象的底层表示。迭代器模式属于行为型模式。迭代器模式已经被淘汰,java中已经把迭代器运用到各个聚集类(collection)中了,使用java自带的迭代器就已经满足我们的需求了 目录 迭代器模式(Iterator) (1)优点 (2)缺点 (3)使用场景 (4)注意事项 (5)应用实例: 代码
25 0
|
9月前
|
设计模式 存储 Java
迭代器模式
迭代器模式(Iterator Pattern)是一种行为型设计模式,它提供了一种顺序访问聚合对象中每个元素的方法,而不暴露其内部实现。
57 1
|
10月前
|
容器
关于迭代器模式我所知道的
关于迭代器模式我所知道的
40 0
|
11月前
|
设计模式 Java 索引
Java设计模式-迭代器模式(Iterator)
Java设计模式-迭代器模式(Iterator)
|
JavaScript 前端开发
简单理解迭代器模式
这几天研究了一下迭代器模式,期间有一段时间经常搞不太懂一些概念与概念之间的关系,今天来整理一下。
102 0
|
设计模式 算法 Java
Java设计模式 ->迭代器模式
Java设计模式 ->迭代器模式
64 0
|
设计模式 存储 容器
我学会了,迭代器模式
迭代器模式属于行为型模式,这个类型的设计模式总结出了 类、对象之间的经典交互方式,将类、对象的行为和使用解耦了,花式的去使用对象的行为来完成特定场景下的功能。
83 0
我学会了,迭代器模式
|
Java 容器
迭代器模式
迭代器模式
82 0