Modèle de conception de l’itérateur en Java

Le modèle de conception de l’itérateur est l’un des modèles comportementaux. Le modèle d’itérateur est utilisé pour fournir un moyen standard de traverser un groupe d’objets. Le modèle d’itérateur est largement utilisé dans le Framework de Collection Java. L’interface de l’itérateur fournit des méthodes pour traverser une collection.

Modèle de conception de l’itérateur

Selon GoF, l’intention du modèle de conception de l’itérateur est:

Fournit un moyen d’accéder aux éléments d’un objet agrégé sans exposer sa représentation sous-jacente.

Le modèle d’itérateur ne se limite pas uniquement à traverser une collection, nous pouvons fournir différents types d’itérateurs en fonction de nos besoins. Le modèle de conception de l’itérateur masque l’implémentation réelle du parcours à travers la collection et les programmes clients utilisent simplement les méthodes de l’itérateur.

Exemple de modèle d’itérateur

Essayons de comprendre le modèle de l’itérateur avec un exemple simple. Supposons que nous ayons une liste de chaînes de radio et que le programme client veuille les parcourir une par une ou en fonction du type de chaîne. Par exemple, certains programmes clients s’intéressent uniquement aux chaînes anglaises et veulent les traiter uniquement, ils ne veulent pas traiter d’autres types de chaînes. Nous pouvons donc fournir une collection de chaînes au client et lui permettre d’écrire la logique pour parcourir les chaînes et décider s’il faut les traiter. Mais cette solution présente de nombreux problèmes, comme le fait que le client doit élaborer la logique de parcours. Nous ne pouvons pas garantir que la logique du client est correcte. De plus, si le nombre de clients augmente, il deviendra très difficile à maintenir. Ici, nous pouvons utiliser le modèle de l’itérateur et fournir une itération basée sur le type de chaîne. Nous devrions nous assurer que le programme client ne peut accéder à la liste des chaînes que par l’itérateur. La première partie de la mise en œuvre consiste à définir le contrat pour nos interfaces de collection et d’itérateur. ChannelTypeEnum.java

package com.journaldev.design.iterator;

public enum ChannelTypeEnum {

	ENGLISH, HINDI, FRENCH, ALL;
}

ChannelTypeEnum est une énumération Java qui définit tous les différents types de chaînes. Channel.java

package com.journaldev.design.iterator;

public class Channel {

	private double frequency;
	private ChannelTypeEnum TYPE;
	
	public Channel(double freq, ChannelTypeEnum type){
		this.frequency=freq;
		this.TYPE=type;
	}

	public double getFrequency() {
		return frequency;
	}

	public ChannelTypeEnum getTYPE() {
		return TYPE;
	}
	
	@Override
	public String toString(){
		return "Frequency="+this.frequency+", Type="+this.TYPE;
	}
	
}

Channel est une classe POJO simple qui possède des attributs de fréquence et de type de chaîne. ChannelCollection.java

package com.journaldev.design.iterator;

public interface ChannelCollection {

	public void addChannel(Channel c);
	
	public void removeChannel(Channel c);
	
	public ChannelIterator iterator(ChannelTypeEnum type);
	
}

L’interface ChannelCollection définit le contrat pour l’implémentation de notre classe de collection. Remarquez qu’il existe des méthodes pour ajouter et supprimer un canal, mais il n’y a pas de méthode qui retourne la liste des canaux. ChannelCollection a une méthode qui retourne l’itérateur pour le parcours. L’interface ChannelIterator définit les méthodes suivantes; ChannelIterator.java

package com.journaldev.design.iterator;

public interface ChannelIterator {

	public boolean hasNext();
	
	public Channel next();
}

Maintenant que notre interface de base et nos classes principales sont prêtes, procédons à l’implémentation de la classe de collection et de l’itérateur. ChannelCollectionImpl.java

package com.journaldev.design.iterator;

import java.util.ArrayList;
import java.util.List;

public class ChannelCollectionImpl implements ChannelCollection {

	private List<Channel> channelsList;

	public ChannelCollectionImpl() {
		channelsList = new ArrayList<>();
	}

	public void addChannel(Channel c) {
		this.channelsList.add(c);
	}

	public void removeChannel(Channel c) {
		this.channelsList.remove(c);
	}

	@Override
	public ChannelIterator iterator(ChannelTypeEnum type) {
		return new ChannelIteratorImpl(type, this.channelsList);
	}

	private class ChannelIteratorImpl implements ChannelIterator {

		private ChannelTypeEnum type;
		private List<Channel> channels;
		private int position;

		public ChannelIteratorImpl(ChannelTypeEnum ty,
				List<Channel> channelsList) {
			this.type = ty;
			this.channels = channelsList;
		}

		@Override
		public boolean hasNext() {
			while (position < channels.size()) {
				Channel c = channels.get(position);
				if (c.getTYPE().equals(type) || type.equals(ChannelTypeEnum.ALL)) {
					return true;
				} else
					position++;
			}
			return false;
		}

		@Override
		public Channel next() {
			Channel c = channels.get(position);
			position++;
			return c;
		}

	}
}

Remarquez l’implémentation de la classe interne de l’interface itératrice afin que l’implémentation ne puisse pas être utilisée par une autre collection. La même approche est suivie par les classes de collection également et toutes ont une implémentation de classe interne de l’interface Iterator. Écrivons un programme de test de modèle de l’itérateur simple pour utiliser notre collection et notre itérateur pour parcourir la collection de canaux. IteratorPatternTest.java

package com.journaldev.design.iterator;

public class IteratorPatternTest {

	public static void main(String[] args) {
		ChannelCollection channels = populateChannels();
		ChannelIterator baseIterator = channels.iterator(ChannelTypeEnum.ALL);
		while (baseIterator.hasNext()) {
			Channel c = baseIterator.next();
			System.out.println(c.toString());
		}
		System.out.println("******");
		 // Itérateur de type de canal
		ChannelIterator englishIterator = channels.iterator(ChannelTypeEnum.ENGLISH);
		while (englishIterator.hasNext()) {
			Channel c = englishIterator.next();
			System.out.println(c.toString());
		}
	}

	private static ChannelCollection populateChannels() {
		ChannelCollection channels = new ChannelCollectionImpl();
		channels.addChannel(new Channel(98.5, ChannelTypeEnum.ENGLISH));
		channels.addChannel(new Channel(99.5, ChannelTypeEnum.HINDI));
		channels.addChannel(new Channel(100.5, ChannelTypeEnum.FRENCH));
		channels.addChannel(new Channel(101.5, ChannelTypeEnum.ENGLISH));
		channels.addChannel(new Channel(102.5, ChannelTypeEnum.HINDI));
		channels.addChannel(new Channel(103.5, ChannelTypeEnum.FRENCH));
		channels.addChannel(new Channel(104.5, ChannelTypeEnum.ENGLISH));
		channels.addChannel(new Channel(105.5, ChannelTypeEnum.HINDI));
		channels.addChannel(new Channel(106.5, ChannelTypeEnum.FRENCH));
		return channels;
	}

}

Lorsque j’exécute le programme ci-dessus, il produit la sortie suivante;

Frequency=98.5, Type=ENGLISH
Frequency=99.5, Type=HINDI
Frequency=100.5, Type=FRENCH
Frequency=101.5, Type=ENGLISH
Frequency=102.5, Type=HINDI
Frequency=103.5, Type=FRENCH
Frequency=104.5, Type=ENGLISH
Frequency=105.5, Type=HINDI
Frequency=106.5, Type=FRENCH
******
Frequency=98.5, Type=ENGLISH
Frequency=101.5, Type=ENGLISH
Frequency=104.5, Type=ENGLISH

Points Importants du Modèle de Conception de l’Iterateur

• Le modèle de conception de l’itérateur est utile lorsque vous souhaitez fournir un moyen standard de parcourir une collection et de masquer la logique d’implémentation du programme client.
• La logique d’itération est intégrée dans la collection elle-même et elle aide le programme client à itérer facilement sur eux.

Modèle de conception de l’itérateur dans JDK

Nous savons tous que l’itérateur de la bibliothèque de collections est le meilleur exemple de mise en œuvre du modèle d’itérateur, mais saviez-vous que la classe java.util.Scanner implémente également l’interface Iterator. Lisez cet article pour en savoir plus sur la classe Java Scanner. C’est tout pour le modèle de conception de l’itérateur, j’espère que c’est utile et facile à comprendre.