Programmation Java/Itérations

Les instructions itératives permettent de répéter l'exécution d'une ou plusieurs instructions, jusqu'à une condition de fin de boucle spécifique : compteur ayant dépassé une limite, changement d'état d'une condition... Java offre deux instructions permettant de réaliser des traitements itératifs : while, for. De plus, les instructions break et continue permettent d'altérer le déroulement des boucles.

Programmation Java

Version imprimable

[ Modifier le sommaire ]

Bloc de portée

Tableaux

Quand plusieurs instructions sont répétées, elles doivent être contenues dans un bloc d'instructions entre accolades.

Instruction while

L'instruction while continue d'exécuter le traitement situé dans la boucle tant que la condition indiquée est vérifiée :

while (condition)
{
    // instructions à exécuter
}

Exemple :

String s = "gro.skoobikiw.rf";
int i = s.length();
while (i>0)
{
    i--; // Décrémenter i
    System.out.print(s.charAt(i));
}
System.out.println();
// Affiche le contenu de la chaîne à l'envers : fr.wikibooks.org

Une autre forme du while évalue la condition à la fin de chaque cycle, plutôt qu'au début. Le bloc d'instruction est donc toujours exécuté au moins une fois :

do
{
    // instructions à exécuter
}
while (condition);

Instruction for

L'instruction for permet d'exécuter un traitement de manière répétitive, mais en spécifiant différemment la condition d'arrêt.

À l'intérieur des parenthèses se trouvent trois blocs d'instructions séparés par un point-virgule. L'exécution de la boucle for commence par exécuter le premier bloc, qui sert généralement à initialiser une variable. Ensuite le second bloc est exécuté (la condition). Si la condition retourne la valeur booléenne true, le corps de la boucle for est exécuté (le bloc d'instruction entre accolade). Sinon l'exécution de la boucle for se termine. Si le corps de la boucle a été exécuté, le troisième bloc est exécuté (incrémenter une variable en général) et le processus recommence : la condition est évaluée, etc.

Voici un exemple typique d'une boucle for qui défini un compteur pour exécuter la boucle i fois. En d'autres termes, le traitement est effectué tant que le compteur n'a pas atteint une limite :

for (int i=0 ; i<limite ; i=i+increment)
{
    // instructions à exécuter
}

Exemple :

String s = "gro.skoobikiw.rf";
for (i=s.length()-1 ; i>=0 ; i--)
    System.out.print(s.charAt(i));
System.out.println();
// Affiche le contenu de la chaîne à l'envers : fr.wikibooks.org

Environnement concurrentiel

L'accès aux données par l'intermédiaire des itérateurs est par essence séquentiel, deux threads ne peuvent bien sur pas utiliser le même itérateur, un objet ne peut pas fournir un itérateur à plusieurs threads. Il est conseillé d'utiliser dans ce cas les classes spécialisées de java.util.concurrent.

Sauts dans le code

Java permet de faire des sauts dans le code lors de l'exécution d'une boucle. C'est en général une mauvaise idée et il faut, autant que possible éviter de recourir à ces pratiques. Ces sauts sont toutefois utilisés notamment avec les boucles imbriquées pour éviter des conditions complexes pouvant être sources de confusion et de problèmes.

Il s'agit des instructions break qui permet de sortir immédiatement de la boucle (c'est-à-dire de sauter immédiatement à la première instruction qui suit la boucle) ou de l'instruction continue qui permet de ne pas exécuter le reste de l'itération en cours et passer à l'itération suivante, c'est-à-dire de sauter immédiatement au bloc d'incrémentation et à une nouvelle évaluation de la condition.

L'utilisation demeure obligatoire pour interrompre une boucle de type for each car la condition de boucle n'est pas modifiable. La boucle de type for each sera vue aussi dans les prochains chapitres : elle permet de parcourir les éléments des tableaux, des collections, et des classes itérables.

Exemple :

String[] theme_calendrier = { "Date", "Heure", "Jour de la semaine" };

for(String page : theme_calendrier)
    if (page.equals("Heure"))
    {
        System.out.println("Page trouvée.");
        break; // Interrompt la boucle la plus proche : for
    }

Un label peut être associé à une instruction de boucle ou un bloc d'instructions pour interrompre une boucle de plus haut niveau, et poursuivre l'exécution après l'instruction ou le bloc nommé.

Exemple :

String[][] pages_thematiques =
{
    // POO
    { "Classe", "Attribut", "Héritage" },
    // Calendrier
    { "Date", "Heure", "Jour de la semaine" },
    // Cuisine
    { "Recette", "Ustensiles", "Techniques" },
};

l_recherche:
{
    for(String[] pages : pages_thematiques)
    {
        for(String page : pages)
            if (page.equals("Heure"))
            {
                 System.out.println("Page trouvée.");
                 break l_recherche;
            }
    }
    System.out.println("Page non trouvée."); // Non exécuté si page trouvée.
}

Pour les collections

Le chapitre Collections montrera que ce type d'objet possède sa propre itération : pour chaque objet d'une collection.