Java >> Tutoriel Java >  >> Java

Boucle for Java avec exemples

Java

Est-il juste de dire qu'un bon programmeur doit avoir une compréhension approfondie des boucles ? Cela pourrait être une question oui ou non, mais manque également de sens sans justification. En bref, qu'est-ce qu'une boucle ? Une boucle est un programme qui itère/répète plusieurs fois jusqu'à ce qu'une condition spécifique soit remplie. Les boucles restent les mêmes quel que soit le langage de programmation que vous utilisez.

Le but des boucles

Disons que vous devez afficher un message 500 fois, et qu'il est très fastidieux et long de taper le même message 500 fois, c'est pourquoi les boucles sont si importantes. Vous pouvez écrire le message une fois et parcourir 499 fois en seulement quelques lignes de code. C'est la puissance des boucles.
Exemple :

package javaforloops;

public class JavaForLoops {
    public static void main(String[] args)
    {
        System.out.println("=====Using normal program ======");
        int numbers; 
        numbers = 1; 
        System.out.println(numbers); 
        numbers=2; 
        System.out.println(numbers); 
        numbers=3; 
        System.out.println(numbers); 
        numbers=4; 
        System.out.println(numbers); 
        numbers=5; 
        System.out.println(numbers); 
        
        //using java for loop
        System.out.println("======Using for Loop=======");

    for(int i=1;i<=5;i++)
    {
        System.out.println(i);
    }
    }
    
}

Sortie : 

run:
=====Using normal program ======
1
2
3
4
5
======Using for Loop=======
1
2
3
4
5
BUILD SUCCESSFUL (total time: 0 seconds)

Dans le code ci-dessus, la première section montre un code Java normal sans boucle for tandis que la deuxième partie utilise la boucle for pour produire les mêmes résultats. Quels sont certains des inconvénients de ne pas utiliser la boucle for ?

  • Répétition du code :C'est bien et recommandé d'éviter au maximum la répétition de code en tant que bon programmeur. Et si nous avions environ 100 messages ? Nous répéterons le même message 100 fois; c'est un code inutile.
  • Code fixe :le code est fixe pour n'imprimer que 1-5. Si nous avons besoin d'un certain modèle, nous écrirons à nouveau un autre programme avec une structure fixe écrite de manière répétitive.
  • Évolutivité :le code n'est pas évolutif. Si nous devons imprimer 1-10, nous ajouterons 5 lignes de code supplémentaires et utiliserons la boucle for. Nous avons seulement besoin de changer la plage à 10. La boucle for est hautement évolutive.

Types de boucles

Il existe 3 types de boucles.

  • Boucle For
  • Boucle While
  • Boucle Do-while

Nous utilisons une boucle for a lorsque nous connaissons le nombre spécifique de fois que nous devons parcourir un bloc de code et une boucle while lorsque nous ne sommes pas sûrs du nombre de fois que nous devons parcourir un bloc de code. Nous l'utilisons pour une boucle do-while lorsque nous devons exécuter la boucle au moins une fois.

Avec ce peu d'introduction, sachons plonger dans Java for loop.

Java pour la boucle.

Comme nous l'avons mentionné précédemment, nous utilisons Java pour une boucle lorsque nous connaissons le nombre exact de fois que vous devez parcourir un bloc de code.

Syntaxe de la boucle for java

for (statement 1; statement 2; statement 3)
{
  //The java for loop code to be executed goes here
}

Types de boucles for Java

Il existe 3 types de boucles for en Java. Ceux-ci comprennent
1. Boucle for simple
2. Boucle for-each/boucle for améliorée
3. Étiqueté pour la boucle

Boucle for simple

Syntaxe d'une boucle for simple

for(initialization; condition; increment/decrement)
{
  //the code of the simple for loop goes here
}

Initialisation : C'est la première partie de la boucle java for que nous déclarons et initialisons une variable en lui attribuant une valeur. C'est la condition initiale qui est exécutée une fois avant le bloc de boucle for de l'exécution du code.
Exemple : 

Int k = 0;

Condition : C'est la deuxième partie qui forme la condition, elle renvoie une valeur booléenne "vrai" ou "faux". Cela signifie que si la condition est vraie, la boucle recommencera et si la condition est fausse, la boucle se terminera.
Exemple : 

K <= 100; or K >= 100;

Incrémentation/Décrémentation : C'est la partie qui ajoute ou diminue des valeurs dans la boucle for. Il est exécuté à chaque fois après le bloc d'exécution du code.
Exemple : 

//Increment
K++
//decrement
K--

Organigramme d'une simple boucle for java

Exemple de boucle for simple Java

package javaforloops;

public class JavaForLoops {
    public static void main(String[] args)
    {
    for(int i=0;i<=2;i++)
    {
        System.out.println("I Have Understood a simple java for loop");
    
    }
    }
    
}

Sortie : 

run:
I Have Understood a simple java for loop
I Have Understood a simple java for loop
I Have Understood a simple java for loop
BUILD SUCCESSFUL (total time: 0 seconds)

Dans l'exemple de boucle for java simple ci-dessus, dans la partie d'initialisation, nous avons déclaré une variable i et initialisé à 0. Il s'agit donc de boucler le corps pour imprimer "J'ai compris une boucle for Java simple" lorsque la condition est inférieure ou égale à 2, puis il se déplace pour incrémenter une valeur de 1.

Supposons que le résultat dans la partie condition soit vrai. La boucle imprime le message et incrémente sa valeur de 1. Lorsque la condition est fausse, i=3 et 3<=2 (est faux), la boucle se termine.

Parfois, vous pouvez avoir plus d'un argument dans la partie condition pour vérifier la condition. Nous ne pouvons pas séparer les deux conditions par une virgule, mais nous pouvons utiliser les conjonctions "ET" ou "OU". 

package javaforloops;

public class JavaForLoops {
    public static void main(String[] args)
    {
        int b = 4, c = 5;
    System.out.println("=== Conjuction AND ===");
    for(int a=2;a<=b && a<=c ;a++)
    {
        System.out.println("Hello java");
    
    }
    System.out.println("=== Conjuction OR ===");
    for(int a=4;a<=b || a<=c ;a++)
    {
        System.out.println("Hello java");
    
    }
    }
    
}

Sortie : 

run:
=== Conjuction AND ===
Hello java
Hello java
Hello java
=== Conjuction OR ===
Hello java
Hello java
BUILD SUCCESSFUL (total time: 0 seconds)

Boucle for-each/Boucle for améliorée

Pour parcourir les éléments d'un tableau ou d'une collection, nous utilisons une boucle for-each ou une boucle for améliorée. Dans cette boucle, nous n'avons pas besoin de la partie incrémentale/décrémentale.

Syntaxe

//array
for(variable type : array)
{
//code to be executed
}
//collection
for(object var :Collection )
{
//code to be executed
}

Exemple de boucle for améliorée

package javaforloops;
public class JavaForLoops {
    public static void main(String[] args)
    {  
	int arr[]={100,101,102,103,110};  
	//Printing array using for-each loop  
	for(int array:arr){  
	 System.out.println(array);  
	}
    } 
}

Sortie : 

run:
100
101
102
103
110
BUILD SUCCESSFUL (total time: 0 seconds)

Y a-t-il des avantages à parcourir un tableau en utilisant une boucle for améliorée plutôt qu'une simple boucle for java? Une boucle for java améliorée simplifie le travail, mais elle est immuable. Dans une boucle for simple, vous pouvez modifier les valeurs à l'intérieur de la boucle, mais dans une boucle for améliorée, l'objet utilisé pour le croisement est immuable. Regardons cela en utilisant un exemple.

package javaforloops;

public class JavaForLoops {
    public static void main(String[] args)
    {  
	 String array[] = { "Java", "Python", "Html", "Machine Learning" }; 
        // enhanced for loop 
        for (String languages : array) { 
            System.out.println(languages); 
        } 
        // for loop for same function  
        for (int languages = 0; languages < array.length; languages++)  
        {  
            System.out.println(array[languages]);  
        }  
    }
}

Java étiqueté pour la boucle

Dans une boucle for imbriquée, nous pouvons décider d'avoir un nom pour les boucles for java. Nous utilisons une étiquette avant la boucle, et cela forme le java étiqueté pour une boucle. Il est principalement utilisé pour la boucle imbriquée pour rompre ou continuer à partir de la boucle "for" spécifique à l'aide de l'étiquette.

Syntaxe

LabelName:
for(initialization; condition; increment/decrement)
{
//code to be executed
}

Exemple d'une boucle for étiquetée

package javaforloops;

public class JavaForLoops {
    public static void main(String[] args)
    {    
       Loop1:  
       for(int i=1;i<=2;i++){  
              Loop2:  
                  for(int j=1;j<=2;j++){  
                      if(i==2 && j==2){  
                          break Loop1;  
                      }  
                      System.out.println(i+" "+j);  
                  }  
    }
    }   
}

Java Infinitif pour la boucle

Le code Java infinitif pour la boucle s'exécute en continu sans fin jusqu'à ce que la mémoire soit épuisée.
Parfois, nous utilisons (;;) pour indiquer java infinitif java for loop. La partie condition ne renverra jamais false pour que la boucle se termine.
Exemple : 

package javaforloops;
public class JavaForLoops {
    public static void main(String[] args)
    {    
        for(int k =2 ; k >= 2; k++){
              System.out.println("The value of i is: "+k);
         }

    }   
}

La partie d'initialisation déclare une variable K et l'initialise à 2. Ensuite, nous vérifions que la valeur de K est égale ou supérieure à K. Puisque nous incrémentons la valeur de K, elle serait toujours supérieure à 2 ; donc l'expression booléenne (K>=2) ne renverra jamais faux. Cela conduira à une condition de boucle infinitive.

Java imbriqué pour la boucle

C'est une boucle à l'intérieur d'une autre boucle. Pour que la boucle externe s'exécute, la boucle interne doit s'exécuter complètement.
Exemple : 

package javaforloops;
public class JavaForLoops {
    public static void main(String[] args)
    {    
       	for(int i=1;i<=5;i++)
        {  
	for(int k=1;k<=i;k++)
        {  
	        System.out.print("* ");  
	}  
	System.out.println(); 
	}  
    }   
}

Dans l'exemple ci-dessus, dans la première boucle, nous initialisons i à 1, la boucle imprime une nouvelle ligne tant que les lignes sont inférieures ou égales à fine (i<=5). Dans la boucle imbriquée, nous initialisons k à 1. La boucle s'exécute et imprime (*) tant que k<=i. nous fermons la boucle intérieure avant de fermer la boucle extérieure. Il est important d'imbriquer les boucles pour obtenir la sortie souhaitée.

Comment utiliser continue en java for loop.

L'instruction continue est principalement utilisée dans la boucle for pour sauter immédiatement au début de la prochaine itération de la boucle.


Exemple

package javaforloops;
public class JavaForLoops {
    public static void main(String[] args)
    {    
     int [] numbers = {1, 2, 3, 4, 5};

      for(int k : numbers ) {
         if( k == 4 ) {
            continue;
         }
         System.out.println( k );
         
      }
  
    }   
}

Sortie : 

run:
1
2
3
5
BUILD SUCCESSFUL (total time: 0 seconds)

D'après la sortie du code ci-dessus, la valeur de sortie 4 est manquante, mais nous l'avons initialisée dans notre tableau. En effet, lorsque le code s'exécute et lorsque l'instruction continue est rencontrée, il saute au début de la boucle pour l'itération suivante, ignorant ainsi l'instruction d'itération en cours. À ce stade, nous pouvons dire que le bloc de code de println ne s'est pas exécuté lorsque k était égal à 4.

Comment utiliser break en java for loop

L'instruction break est utilisée lorsque nous voulons sortir de la boucle for.
Exemple. 

package javaforloops;
public class JavaForLoops {
    public static void main(String[] args)
    {    
     int [] numbers = {1, 2, 3, 4, 5};

      for(int k : numbers ) {
         if( k == 4 ) {
            break;
         }
         System.out.println( k );
         
      }
  
    }   
}

Sortie : 

run:
1
2
3
BUILD SUCCESSFUL (total time: 0 seconds)

D'après la sortie du code ci-dessus, les valeurs de sortie 4 et 5 sont manquantes, mais nous les avons initialisées dans notre tableau. En effet, la boucle se termine lorsqu'elle atteint la condition où k était égal à 4.

Conclusion

En résumé, dans ce didacticiel, nous avons appris les boucles for java, leur syntaxe et leurs types. Nous avons également examiné la boucle infinitive, la boucle imbriquée, l'instruction break dans la boucle for et l'instruction continue dans la boucle for java. Notez que les variables déclarées dans une boucle for sont des variables locales et que nous ne pouvons pas y accéder après la fin de la boucle. C'est parce que les variables déclarées à l'intérieur d'un bloc d'instructions ont leur portée uniquement dans le bloc.


Balise Java