Java pour la boucle

Dans ce didacticiel, nous apprendrons à utiliser la boucle for en Java à l'aide d'exemples et nous découvrirons également le fonctionnement de la boucle en programmation informatique.

En programmation informatique, les boucles sont utilisées pour répéter un bloc de code. Par exemple, si vous voulez afficher un message 100 fois, plutôt que de taper le même code 100 fois, vous pouvez utiliser une boucle.

En Java, il existe trois types de boucles.

boucle for
boucle while
boucle faire...while

Ce tutoriel se concentre sur la boucle for. Vous découvrirez les autres types de boucles dans les prochains didacticiels.

Java pour la boucle

Java for La boucle est utilisée pour exécuter un bloc de code un certain nombre de fois. La syntaxe de for boucle est :

for (initialExpression; testExpression; updateExpression) {
    // body of the loop
}

Ici,

L'expressioninitiale initialise et/ou déclare des variables et ne s'exécute qu'une seule fois.
La condition est évalué. Si la condition est true , le corps du for boucle est exécutée.
La expression de mise à jour met à jour la valeur de initialExpression .
La condition est à nouveau évalué. Le processus se poursuit jusqu'à la condition est false .

Pour en savoir plus sur les conditions, consultez les opérateurs relationnels et logiques Java.

Exemple 1 :Afficher un texte cinq fois

// Program to print a text 5 times

class Main {
  public static void main(String[] args) {

    int n = 5;
    // for loop  
    for (int i = 1; i <= n; ++i) {
      System.out.println("Java is fun");
    }
  }
}

Sortie

Java is fun
Java is fun
Java is fun
Java is fun
Java is fun

Voici comment fonctionne ce programme.

Itération	Variable	Condition :i <=n	Action
1er	`i = 1` `n = 5`	`true`	`Java est amusant` est imprimé. `je` est porté à 2 .
2ème	`i = 2` `n = 5`	`true`	`Java est amusant` est imprimé. `je` est porté à 3 .
3ème	`i = 3` `n = 5`	`true`	`Java est amusant` est imprimé. `je` est porté à 4 .
4ème	`i = 4` `n = 5`	`true`	`Java est amusant` est imprimé. `je` est porté à 5 .
5ème	`i = 5` `n = 5`	`true`	`Java est amusant` est imprimé. `je` est porté à 6 .
6ème	`i = 6` `n = 5`	`false`	La boucle est terminée.

Exemple 2 :Afficher les nombres de 1 à 5

// Program to print numbers from 1 to 5

class Main {
  public static void main(String[] args) {
  
    int n = 5;
    // for loop  
    for (int i = 1; i <= n; ++i) {
      System.out.println(i);
    }
  }
}

Sortie

Voici comment fonctionne le programme.

Itération	Variable	Condition :i <=n	Action
1er	`i = 1` `n = 5`	`true`	`1` est imprimé. `je` est porté à 2 .
2ème	`i = 2` `n = 5`	`true`	`2` est imprimé. `je` est porté à 3 .
3ème	`i = 3` `n = 5`	`true`	`3` est imprimé. `je` est porté à 4 .
4ème	`i = 4` `n = 5`	`true`	`4` est imprimé. `je` est porté à 5 .
5ème	`i = 5` `n = 5`	`true`	`5` est imprimé. `je` est porté à 6 .
6ème	`i = 6` `n = 5`	`false`	La boucle est terminée.

Exemple 3 :Afficher la somme de n nombres naturels

// Program to find the sum of natural numbers from 1 to 1000.

class Main {
  public static void main(String[] args) {
      
    int sum = 0;
    int n = 1000;

    // for loop
    for (int i = 1; i <= n; ++i) {
      // body inside for loop
      sum += i;     // sum = sum + i
    }
       
    System.out.println("Sum = " + sum);
  }
}

Sortie :

Sum = 500500

Ici, la valeur de sum est 0 initialement. Ensuite, la boucle for est itérée à partir de i = 1 to 1000 . À chaque itération, je est ajouté à somme et sa valeur est augmentée de 1 .

Quand je devient 1001 , la condition de test est false et somme sera égal à 0 + 1 + 2 + .... + 1000 .

Le programme ci-dessus pour additionner la somme des nombres naturels peut aussi s'écrire

// Program to find the sum of natural numbers from 1 to 1000.

class Main {
  public static void main(String[] args) {
      
    int sum = 0;
    int n = 1000;

    // for loop
    for (int i = n; i >= 1; --i) {
      // body inside for loop
      sum += i;     // sum = sum + i
    }
       
    System.out.println("Sum = " + sum);
  }
}

La sortie de ce programme est la même que celle de l'exemple 3 .

Boucle Java for-each

La boucle for Java a une syntaxe alternative qui facilite l'itération dans les tableaux et les collections. Par exemple,

// print array elements 

class Main {
  public static void main(String[] args) {
      
    // create an array
    int[] numbers = {3, 7, 5, -5};
    
    // iterating through the array 
    for (int number: numbers) {
       System.out.println(number);
    }
  }
}

Sortie

Ici, nous avons utilisé la boucle for-each pour imprimer chaque élément des nombres tableau un par un.

Dans la première itération de la boucle, nombre sera 3, nombre sera 7 à la deuxième itération et ainsi de suite.

Pour en savoir plus, visitez Java for-each Loop.

Java Infinite pour la boucle

Si nous définissons l'expression de test de telle sorte qu'il ne soit jamais évalué à false , le for la boucle s'exécutera indéfiniment. C'est ce qu'on appelle une boucle for infinie. Par exemple,

// Infinite for Loop

class Infinite {
    public static void main(String[] args) {
      
        int sum = 0;

        for (int i = 1; i <= 10; --i) {
            System.out.println("Hello");
        }
    }
}

Ici, l'expression de test ,i <= 10 , n'est jamais false et Hello est imprimé à plusieurs reprises jusqu'à ce que la mémoire soit épuisée.

Déclaration de commutateur Java Java pour chaque boucle

Java