Médiaforma

Java – Instructions répétitives

Print Friendly

Instructions répétitives

Dans un programme, il est souvent nécessaire de faire exécuter plusieurs fois un même bloc d’instructions. Plutôt que de répéter plusieurs fois ce bloc, il est plus judicieux d’utiliser une instruction de répétition. Java dispose de trois instructions de ce type : for, do while et while. Nous allons examiner leur fonctionnement dans les pages suivantes.

L’instruction for

L’instruction for exécute de façon répétitive un bloc d’instructions tant qu’une condition est vérifiée. Cette condition est basée sur la valeur d’une variable incrémentée par l’instruction.

Voici la syntaxe de l’instruction for :

for (expression 1; expression 2; expression 3){
  instruction 1;
  ...
  instruction N;
}
  • expression 1 initialise la variable compteur utilisée dans la boucle ;
  • expression 2 définit la condition qui doit être vérifiée pour que la boucle se poursuive ;
  • expression 3 indique comment faire varier la variable compteur utilisée dans expression 2 ;
  • instruction 1 à instruction N sont les instructions ou appels de procédures/fonctions exécutés tant que l’expression 2 est vérifiée.

L’instruction while

L’instruction while exécute de façon répétitive un bloc d’instructions tant qu’une condition est vérifiée. Le test de la condition est fait avant l’exécution de la boucle.

Voici la syntaxe de l’instruction while :

while (expression) {
  instruction 1;
  ...
  instruction N;
}

expression est une condition qui doit être vérifiée pour que les instructions de la boucle s’exécutent, et instruction 1 à instruction N sont les instructions ou appels de procédures/fonctions exécutés tant que l’expression est vérifiée.

L’instruction do while

L’instruction do while se comporte comme l’instruction while, mais le test de la condition de bouclage est réalisé après avoir exécuté le bloc d’instructions. Il en découle que le bloc d’instructions est au moins exécuté une fois dans une boucle do while, alors qu’il peut ne pas l’être dans la même boucle while.

Voici la syntaxe de l’instruction do while :

do {
  instruction 1;
  ...
  instruction N;
}
while (expression);

expression est une condition logique qui fixe la ré exécution ou l’arrêt du bloc d’instructions, et instruction 1 à instruction N sont les instructions ou appels de procédures/fonctions exécutés jusqu’à ce que l’expression ne soit plus vérifiée.

Boucle infinie

Pour définir une boucle infinie (c’est-à-dire pour exécuter indéfiniment un bloc d’instructions), vous utiliserez l’une des trois instructions suivantes.

Première possibilité :

for ( ; ; ){
  instructions;
}

Deuxième possibilité :

while (1){
  instructions;
}

Troisième possibilité :

do{
  instructions;
}
while (1);

L’instruction continue

Il est parfois nécessaire d’interdire l’exécution d’une boucle lorsqu’une condition logique est satisfaite. Pour ce faire, vous utiliserez l’instruction continue, en tête du bloc :

Dans une instruction for :

for (expression 1; expression 2; expression 3){
  if (condition)
    continue;
  instruction 1;
  ...
  instruction N;
}

Dans une instruction while :

while (expression){
  if (condition)
    continue;
  instruction 1;
  ...
  instruction N;
}

Dans une instruction do while :

do{
  if (condition)
    continue;
  instruction 1;
  ...
  instruction N;
}
while (expression);

Exemple :

Ce petit programme calcule les valeurs de la fonction y = 1/(x – 3) pour les valeurs comprises entre 2 et 4, par pas de 0.1. Il est nécessaire d’exclure la valeur 3 du calcul. Une instruction continue s’en charge.

public class Fonction {
  public static void main (String args[]) {
    double x;
    for (x=2; x<=4; x+=.1){
      if (((x-3)<0.01) && ((x-3)>-0.01))
        continue; // Interdit l'exécution de la boucle pour x=3
      System.out.println("x= " + x + "  y= " + 1/(x-3));
    }
  }
}

Remarque

Pour tester si x vaut 3, on ne peut pas utiliser l’instruction suivante :

if (x == 3)

Car x est une variable de type double. Par sa nature, elle ne sera jamais égale exactement à 3, mais plutôt à quelque chose comme 3,0000000001.

L’instruction break

Il est parfois utile d’arrêter l’exécution d’une boucle lorsqu’une condition logique est satisfaite. Pour cela, utilisez l’instruction break, en tête du bloc :

Dans une instruction for :

for (expression 1; expression 2; expression 3){
  if (condition)
    break;
  instruction 1;
  ...
  instruction N;
}

Dans une instruction while :

while (expression){
  if (condition)
    break;
  instruction 1;
  ...
  instruction N;
}

Dans une instruction do while :

do{
  if (condition)
    break;
  instruction 1;
  ...
  instruction N;
}
while (expression);

Boucler sur une structure

Le langage Java possède une boucle semblable à l’instruction foreach rencontrée dans de nombreux autres langages. Vous utiliserez cette instruction pour parcourir simplement les éléments d’une structure quelconque (un tableau ou une collection quelconque).

Voici la syntaxe de cette instruction :

for (type variable : structure {
  // Une ou plusieurs instructions
}

Voici un exemple d’utilisation :

public static void main(String[] args) {
    int[] Tableau = {1, 2, 3, 4, 5, 6};
    for (int t:Tableau){
        System.out.println(t);
    }
}

Et voici le résultat, exécuté dans NetBeans :

 

<center><img src= »http://www.mediaforma.com/uneminuteparjour/java/images/java-instructions-repetitives.jpg »></center>

Vous avez aimé cet article ? Partagez-le avec vos réseaux...
 
Comments

No comments yet.

Leave a Reply