Patron Itérateur

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

Le pattern Iterator est un patron de conception comportemental qui permet d'accéder séquentiellement aux éléments d'une collection 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 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 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 conserve 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, c’est pourquoi vous pouvez utiliser des boucles for améliorées avec toute classe qui implémente Iterable. Le modèle d’itérateur 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 playlist à l'aide du pattern Iterator ! Vous allez créer une playlist 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. Il s'agit d'un cas d'utilisation idéal du pattern Iterator, qui permet aux utilisateurs de parcourir votre collection via une interface claire et uniforme.

Vous allez organiser votre code dans quatre fichiers :

Iterator.java : définissez votre interface générique Iterator<T> avec deux méthodes : hasNext(), qui renvoie une valeur booléenne indiquant s'il existe d'autres éléments, et next(), qui renvoie 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 de capacité fixe (transmise au constructeur) et suivre le nombre de chansons ajoutées. Incluez une méthode addSong(String song) pour ajouter des chansons à la playlist.
Votre Playlist a besoin d'une méthode createIterator() qui renvoie un Iterator<String>. Implémentez-la en créant une classe interne privée appelée PlaylistIterator qui implémente votre 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éez une classe Song simple qui encapsule le titre d'une chanson. Elle doit disposer d'un constructeur qui prend le titre (String), d'une méthode getTitle() et d'une méthode toString() qui renvoie Playing: [title].
Main.java : rassemblez votre système d'itération ! 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 pouvant contenir 10 chansons. Analysez l'entrée et ajoutez chaque titre de chanson à la playlist. Obtenez ensuite un itérateur à partir de la playlist et utilisez-le pour parcourir toutes les chansons, en affichant chacune d'elles encapsulée dans un objet Song (qui s'affichera sous la forme Playing: [title]).

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

Vous recevrez 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, 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 playlist 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 !

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: Print "Playlist complete!" after iterating through all songs
    }
}