Les itérateurs: concepts, utilisation en Java et C#

Mise à jour, déménagement de tout le contenu vers le site:
http://www.while-true-do.com

Les articles ont été rénovés et de nouveaux ont été ajoutés.

1. Les itérateurs: concepts
1.1. présentation des itérateurs
Les itérateurs servent à parcourir les conteneurs –appelés aussi collections- de type séquence comme les vecteurs, liste, piles, files, ou autres. Pour le tableau, l’itérateur est simplement un indice qui accède aux éléments via l’opérateur [].

Un itérateur est une sorte de curseur dont le travail est de se déplacer dans une séquence d’objets, d’offrir un accès simple à chaque objet de cette séquence sans se préoccuper de la structure de stockage sous-jacente. De plus, un itérateur est un objet peu coûteux en espace mémoire et rapide à créer et à détruire.

1.2. Types d'itérateurs
Les bibliothèques de certains langages poussent très loin le concept d’itérateurs comme la STL (Standart template Library) de C++. Les environnements de dernière génération comme Java ou .NET ne sont pas en reste, ils proposent en standard de nombreuses collections et différents types d’itérateurs pour les parcourir.

On peut classifier les itérateurs selon le sens possible de déplacement :
  -Itérateurs unidirectionnels :
    Déplacement en avant, c’est le plus standard.
    Déplacement en arrière.

  -Itérateurs Bi-directionnel :
     Déplacement avant-arrière

Mais aussi selon le mode d’accès aux données :
  -Itérateurs en lecture seule
  -Itérateurs en en lecture/Ecriture

1.3. Importance des itérateurs
Le mécanisme des itérateurs offre de nombreux avantages aux programmeurs :

1/ parcours standard et uniforme
Par un niveau d’abstraction élevé, les itérateurs fonctionnent de la même manière quel que soit le conteneur, (et même quel que soit le langage de programmation). Cela réduit d’autant l’apprentissage des itérateurs et donc la maintenance des programmes.

2/ faciliter l’itération des séquences
Avec quelques méthodes, parcourir simplement une séquence d’éléments.

Et avoir même un fonctionnement complexe :
itérateurs bi-directionnels,
insertion/suppression durant une itération,… 

3/ itérations multiples sur un même containeur
C’est un avantage fonctionnel certain comparé à des méthodes basiques qui ne permettent pas (ou difficilement) de multiples itérations sur un containeur.

4/ Couplage « faible » entre code itérateur et le code du containeur
On sépare (dans la mesure du possible) le code d’itération du code de la classe containeur. 

1.4. Stratégie de fonctionnement
La mise en œuvre des itérateurs se veut la plus simple possible. Le fonctionnement des itérateurs a été défini par le pattern d’itération. Ce pattern repris notamment dans le langage Java précise que l’itérateur est un curseur qui désigne une position, avant ou après un élément. A la création de l’itérateur, celui-ci est positionné avant le premier élément de la collection.

L’itérateur est fournit (fabriqué) par la collection elle-même. Deux méthodes suffisent pour gérer l’itérateur. Une première méthode indique s’il existe un élément suivant et renvoie vrai dans ce cas là. Une autre méthode qui se déplace sur l’élément suivant et le renvoi.

2. Les itérateurs en Java
2.1. Les collections en Java
Java dispose de base d’un riche ensemble de collections –les Java Collections Framework- définis par de nombreuses classes et interfaces. Cet ensemble a été remis à neuf depuis la version 1.2 avec l’introduction de plusieurs interfaces pour « abstraire » les conteneurs comme la liste. Les collections ont été unifiées et simplifiées autour de quelques classes et interfaces essentielles. La version 1.5 de Java a apporté la généricité (les templates) et une syntaxe simplifiée (de type foreach) pour le parcours des collections.

En Java, le conteneur en séquence standard est le ArrayList depuis la version 1.2 de Java (plutôt que Vector). Simple et facile à mettre en œuvre, il est largement suffisant pour un usage général de stockage d’objets.

2.2. Itérateurs sur collection en Java
Java met à disposition un itérateur standard basique (classe Iterator) pour parcourir les éléments d’une collection (que dans un seul sens). Java propose aussi un itérateur plus élaboré (classe ListIterator) qui offre un parcours bi-directionnel du conteneur. Voyons la mise en œuvre d’un itérateur sur une collection de type ArrayList.

Le comportement d’une liste d’éléments est modélisé par une interface : List. Cette interface dispose de toutes sortes de méthodes pour offrir les fonctionnalités d’une liste: ajout, suppression d’éléments,…. L’itérateur standard sur les listes est défini par l’interface Iterator dont l’interface List dispose d’un membre. La classe ArrayList hérite de la classe abstraite Abstract List et met en œuvre l’interface List.

L’utilisation d’une liste (ArrayList) et d’un itérateur associé (ou plusieurs si nécessaire) se fait simplement en créant un objet ArrayList et en lui ajoutant des éléments. Ensuite, pour parcourir les éléments, une demande est faite à la liste pour qu’elle fabrique un (ou plusieurs) itérateur sur les éléments qu’elle contient. Cet itérateur sera instancié et positionné automatiquement sur le début de la liste.

Exemple de parcours avec itérateur
Soit un ensemble d’objets personnes (classe Person) stockées dans une collection ArrayList (objet persons). Les éléments sont parcourus un à un et sont affichés.

 // création d’une liste d’éléments
ArrayList persons = new ArrayList();

// remplir la liste d’éléments
Person p= new Person("john", "mith");
persons.add(p);
...

// demande un itérateur au conteneur
Iterator i = persons.iterator();

// tant qu’il un élément suivant dans la collection
while(i.hasNext())
{
    // extrait (une référence sur) l’élément suivant
    Person p= (Person)i.next();

    // traite l’élément extrait: l’affiche
    p.print();
}

Ou dans une version simplifiée plus concise pour le parcours des éléments, possible depuis java 1.5 :

for(Person p : persons)
{
    p.print();
} 

3. Les itérateurs en .NET/C#
3.1. Les collections
Comme en Java, .Net fourni une bibliothèque de conteneurs très riche représentés par des classes et des interfaces. Les comportements des conteneurs sont « abstraits » comme en Java et modélisé par quelques interfaces : IList pour les listes, IDictionnary pour les map.

3.2. Itérateurs sur une collection en C#
Les itérateurs en C# fonctionne de manière identique aux itérateurs de Java. Dans .NET, une collection pouvant être parcourue par un itérateur doit mettre en œuvre l’interface IEnumerable. La classe standard pour gérer une liste d’éléments est ArrayList.

La forme très concise de type foreach pour parcourir les collections existe en standard dans .NET :

// collection d’éléments
protectedArrayList Persons= new ArrayList();

// parcours la liste des objets, les affiche
foreach(Person p in Persons)
       p.Print();

4. Bibliographie
http://www.dotnetguru.org/articles/Comparatifs/JSR201/JavaVsCSharpNews.htm
Article « Java sur les traces de C# », par Sami Jaber (jaber@ifrance.com)
un paragraphe concerne les itérateurs java read-only  un autre concerne le parcours des collections (simples et génériques) via l’instruction foreach.

http://java.sun.com/j2se/1.4.2/docs/guide/collections/index.html.
Documentation Java « Collections Framework », Par Sun. Page d’accueil de la documentation du framework des collections de Sun sur Java

http://java.sun.com/j2se/1.4.2/docs/guide/collections/reference.html
Documentation Java «Annotated Outline of Collections Framework », Par Sun
Liste (API) des conteneurs (classes, interfaces, classes abstraites et autres) de la documentation de Sun

http://www.pps.jussieu.fr/~rifflet/enseignements/JAVA/iterateurs.html
Article « Collections et itérateurs », Par Rifflet
Présente l’interface Iterator et ses méthodes (Java).

http://www.dotnetguru.org/articles/dossiers/iteratorcsharpv2/CS2_Iterators_FR.htm
Article « Les itérateurs de C#2 » , par Patrick Smacchia
article très pointu sur la puissance des itérateurs en .NET #2. (avec une présentation en #1).