[Design Patterns] - 16, modèle itérateur

(16) Mode itérateur

Le modèle d'itérateur fonctionne en fournissant un moyen d'accéder aux collections/conteneurs dans l'ordre sans exposer la représentation interne de la collection. Il peut fournir un comportement de traversée uniforme pour différents conteneurs, quelle que soit la construction des éléments à l'intérieur du conteneur.

1. Principes de conception du modèle d'itérateur

1. Itérateur abstrait : l'itérateur abstrait définit l'interface pour accéder aux éléments et les parcourir ;

2. ConcreateIterator : fournit un comportement de parcours spécifique ;

3. Conteneur abstrait (IAggregate) : définir une interface qui fournit des itérateurs spécifiques ;

4, Conteneur concret (ConcreateAggregate) : Créez un itérateur concret.

2. Exemple simple

Écrivez un itérateur pour itérer sur les informations du cours.

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

public class IteratorImpl<E> implements Iterator<E> {
    
    
//    实现迭代器内部维护一个list，element,index
    private List<E> list;
    private int cursor;
    private E element;

    public IteratorImpl(List<E> list) {
    
    
        this.list = list;
    }

//    获取下一个元素
    @Override
    public E next() {
    
    
        System.out.print("当前位置: "+cursor);
        element = list.get(cursor);
        cursor++;
        return element;
    }

//    判断下一个位置是否有元素
    @Override
    public boolean hasNext() {
    
    
        return cursor > list.size()-1 ? false : true;
    }
}

public interface CourseAggregate {
    
    
    void add(Course course);
    void remove(Course course);
    Iterator<Course> iterator();
}

public class CourseAggregateImpl implements CourseAggregate {
    
    

    private List courseList;

    public CourseAggregateImpl() {
    
    
        this.courseList = new ArrayList();
    }

    @Override
    public void add(Course course) {
    
    
        courseList.add(course);
    }

    @Override
    public void remove(Course course) {
    
    
        courseList.remove(course);
    }

    @Override
    public Iterator<Course> iterator() {
    
    
        return new IteratorImpl<>(courseList);
    }
}

public class Course {
    
    
    private String name;

    public Course(String name) {
    
    
        this.name = name;
    }
	//get,set
}

public class Client {
    
    
    public static void main(String[] args) {
    
    
        Course java = new Course("java");
        Course python = new Course("python");
        Course ai = new Course("ai");

        CourseAggregateImpl courseAggregate = new CourseAggregateImpl();

        courseAggregate.add(java);
        courseAggregate.add(python);
        courseAggregate.add(ai);

        print(courseAggregate);

    }

    public static void print(CourseAggregate courseAggregate) {
    
    
        Iterator<Course> iterator = courseAggregate.iterator();
        while (iterator.hasNext()) {
    
    
            Course course = iterator.next();
            System.out.println(course.getName());
        }
    }
}

3. Commentaires sur le mode itérateur

Le modèle d'itérateur résume l'interface d'itération d'élément fournie par l'objet de collection lui-même à l'itérateur, de sorte que l'objet de collection n'a pas besoin de se soucier du comportement d'itération spécifique. Il s'agit essentiellement d'une encapsulation. Généralement, le mode itérateur peut être utilisé pour itérer la structure de données auto-construite, et l'itérateur fourni avec le framework peut être utilisé pour d'autres.