Patron Itérateur

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy — leçon 76 sur 87.

Le Patron Itérateur (Iterator Pattern) est un patron de conception comportemental qui fournit un moyen d'accéder aux éléments d'une collection de manière séquentielle sans exposer sa structure sous-jacente. Que vous travailliez avec un tableau, une liste chaînée ou un arbre, l'itérateur vous offre un moyen uniforme de parcourir les éléments.

Le patron sépare la logique de parcours de la collection elle-même. Il implique deux composants principaux : une interface Iterator qui définit des méthodes pour parcourir les éléments, et un Iterable (ou Agrégat) qui crée des itérateurs pour sa collection :

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

interface Container<T> {
    Iterator<T> createIterator();
}

class BookShelf implements Container<String> {
    private String[] books;
    private int count = 0;
    
    public BookShelf(int size) {
        books = new String[size];
    }
    
    public void addBook(String book) {
        books[count++] = book;
    }
    
    public Iterator<String> createIterator() {
        return new BookIterator();
    }
    
    private class BookIterator implements Iterator<String> {
        private int index = 0;
        
        public boolean hasNext() {
            return index < count;
        }
        
        public String next() {
            return books[index++];
        }
    }
}

L'itérateur maintient son propre état de parcours, permettant à plusieurs itérateurs de parcourir la même collection de manière indépendante. Les clients utilisent l'itérateur sans savoir comment la collection stocke ses données :

BookShelf shelf = new BookShelf(3);
shelf.addBook("Design Patterns");
shelf.addBook("Clean Code");

Iterator<String> iterator = shelf.createIterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

Les interfaces intégrées Iterable et Iterator de Java suivent exactement ce modèle, c'est pourquoi vous pouvez utiliser des boucles for améliorées avec n'importe quelle classe qui implémente Iterable. Le patron de conception Iterator est essentiel lorsque vous devez fournir plusieurs méthodes de parcours ou masquer des structures internes complexes au code client.

Défi

Facile

Construisons un système de liste de lecture en utilisant le modèle Iterator ! Vous allez créer une liste de lecture musicale qui stocke des chansons et fournit un itérateur personnalisé pour les parcourir séquentiellement — sans exposer la manière dont les chansons sont stockées en interne. C'est un cas d'utilisation parfait pour le modèle Iterator, permettant aux utilisateurs de naviguer dans votre collection via une interface propre et uniforme.

Vous organiserez votre code sur quatre fichiers :

Iterator.java : Définissez votre interface générique Iterator<T> avec deux méthodes : hasNext() qui retourne un booléen indiquant si d'autres éléments existent, et next() qui retourne l'élément suivant de type T.
Playlist.java : Créez la classe agrégée qui contient vos chansons. Votre Playlist doit stocker les chansons dans un tableau de String avec une capacité fixe (passée au constructeur) et suivre le nombre de chansons ajoutées. Incluez une méthode addSong(String song) pour ajouter des chansons à la liste de lecture.
Votre Playlist a besoin d'une méthode createIterator() qui retourne un Iterator<String>. Implémentez cela en créant une classe interne privée appelée PlaylistIterator qui implémente votre interface Iterator. Cet itérateur interne maintient sa propre position d'index et parcourt le tableau de chansons, retournant chaque chanson dans l'ordre.
Song.java : Créez une classe Song simple qui enveloppe un titre de chanson. Elle doit avoir un constructeur qui prend le titre (String), une méthode getTitle(), et une méthode toString() qui retourne "Playing: " + title.
Main.java : Rassemblez votre système d'itérateur ! Vous recevrez une entrée : une liste de titres de chansons séparés par des virgules (par exemple : "Bohemian Rhapsody,Stairway to Heaven,Hotel California").
Créez une Playlist avec une capacité de 10 chansons. Analysez l'entrée et ajoutez chaque titre de chanson à la liste de lecture. Ensuite, obtenez un itérateur de la liste de lecture et utilisez-le pour parcourir toutes les chansons, en affichant chacune enveloppée dans un objet Song (qui s'affichera comme "Playing: " + title).

Après avoir parcouru toutes les chansons, affichez "Playlist complete!" sur une nouvelle ligne.

Vous recevrez une entrée : une chaîne de titres de chansons séparés par des virgules.

Par exemple, avec l'entrée "Yesterday,Imagine,Let It Be", votre sortie serait :

Playing: Yesterday
Playing: Imagine
Playing: Let It Be
Playlist complete!

Remarquez comment votre classe Main utilise les méthodes hasNext() et next() de l'itérateur pour parcourir la liste de lecture sans rien savoir de la structure du tableau sous-jacent. L'itérateur encapsule toute la logique de parcours, gardant la représentation interne de la collection cachée du code client !

Aide-mémoire

Le patron sépare la logique de parcours de la collection elle-même en utilisant deux composants principaux :

Interface Iterator : définit les méthodes pour parcourir les éléments
Iterable/Container : crée des itérateurs pour sa collection

Structure de base

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

interface Container<T> {
    Iterator<T> createIterator();
}

Exemple d'implémentation

class BookShelf implements Container<String> {
    private String[] books;
    private int count = 0;
    
    public BookShelf(int size) {
        books = new String[size];
    }
    
    public void addBook(String book) {
        books[count++] = book;
    }
    
    public Iterator<String> createIterator() {
        return new BookIterator();
    }
    
    private class BookIterator implements Iterator<String> {
        private int index = 0;
        
        public boolean hasNext() {
            return index < count;
        }
        
        public String next() {
            return books[index++];
        }
    }
}

Utilisation

BookShelf shelf = new BookShelf(3);
shelf.addBook("Design Patterns");
shelf.addBook("Clean Code");

Iterator<String> iterator = shelf.createIterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

L'itérateur maintient son propre état de parcours, permettant à plusieurs itérateurs de parcourir la même collection de manière indépendante. Les interfaces intégrées de Java Iterable et Iterator suivent ce patron, permettant l'utilisation des boucles for améliorées.

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        
        // TODO: Créer une Playlist avec une capacité de 10 chansons
        
        // TODO: Analyser l'entrée (séparée par des virgules) et ajouter chaque titre de chanson à la playlist
        
        // TODO: Obtenir un itérateur de la playlist en utilisant createIterator()
        
        // TODO: Utiliser l'itérateur pour parcourir toutes les chansons
        // Pour chaque chanson, l'envelopper dans un objet Song et l'afficher
        
        // TODO: Afficher "Playlist complete!" après avoir parcouru toutes les chansons
    }
}