Patron Itérateur

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

Le patron Iterator est un patron de conception comportemental qui permet d’accéder aux éléments d’une collection de manière séquentielle sans exposer sa structure interne. Que tu travailles avec un tableau, une liste chaînée ou un arbre, l’itérateur te fournit une manière uniforme de parcourir les éléments.

Le modèle sépare la logique de parcours de la collection elle-même. Il comporte 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, ce qui permet à plusieurs itérateurs de parcourir indépendamment la même collection. 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, ce qui explique pourquoi tu peux utiliser les boucles for améliorées avec toute classe qui implémente Iterable. Le modèle Iterator est essentiel lorsque tu dois fournir plusieurs méthodes de parcours ou masquer des structures internes complexes au code client.

Défi

Facile

Créons un système de listes de lecture à l’aide du patron Itérateur ! Tu vas créer une liste de lecture qui stocke des chansons et fournit un itérateur personnalisé pour les parcourir dans l’ordre, sans révéler comment elles sont stockées en interne. C’est un cas d’utilisation idéal du patron Itérateur : il permet aux utilisateurs de parcourir ta collection à l’aide d’une interface claire et uniforme.

Tu vas organiser ton code dans quatre fichiers :

Iterator.java : définis ton interface générique Iterator<T> avec deux méthodes : hasNext(), qui renvoie un booléen indiquant s’il reste des éléments, et next(), qui renvoie l’élément suivant de type T.
Playlist.java : crée la classe agrégat qui contient tes chansons. Ta classe Playlist doit stocker les chansons dans un tableau de String de capacité fixe (transmise au constructeur) et suivre le nombre de chansons ajoutées. Ajoute une méthode addSong(String song) pour ajouter des chansons à la liste de lecture.
Ta classe Playlist a besoin d’une méthode createIterator() qui renvoie un Iterator<String>. Pour cela, crée une classe interne privée appelée PlaylistIterator qui implémente ton interface Iterator. Cet itérateur interne conserve sa propre position d’index et parcourt le tableau de chansons, en renvoyant chaque chanson dans l’ordre.
Song.java : crée une classe simple Song qui encapsule le titre d’une chanson. Elle doit avoir un constructeur qui prend le titre (String), une méthode getTitle() et une méthode toString() qui renvoie Playing: [title].
Main.java : assemble ton système d’itérateur ! Tu recevras 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ée une Playlist pouvant contenir 10 chansons. Analyse l’entrée et ajoute chaque titre de chanson à la liste de lecture. Récupère ensuite un itérateur de la liste de lecture et utilise-le pour parcourir toutes les chansons, en affichant chacune dans un objet Song (qui s’affichera sous la forme Playing: [title]).

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

Tu recevras une entrée : une chaîne contenant des titres de chansons séparés par des virgules.

Par exemple, avec l’entrée Yesterday,Imagine,Let It Be, ta sortie sera :

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

Remarque comment ta 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, ce qui masque la représentation interne de la collection au code client !

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 d'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 à l'aide de createIterator()
        
        // TODO: Utiliser l'itérateur pour parcourir toutes les chansons
        // Pour chaque chanson, l'encapsuler dans un objet Song et l'afficher
        
        // TODO: Afficher "Playlist complete!" après avoir parcouru toutes les chansons
    }
}