Java

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Les boucles en Java

En programmation, une boucle est une séquence d'instructions qui est répétée jusqu'à ce qu'une certaine condition soit atteinte.

  •   Une opération est effectuée, telle que l'obtention et la modification d'un élément de données, puis une condition est vérifiée, par exemple si un compteur a atteint un nombre prescrit.
  •   Compteur non atteint: Si le compteur n'a pas atteint le nombre souhaité, l'instruction suivante de la séquence retourne à la première instruction de la séquence et la répète.
  •   Compteur atteint: Si la condition est atteinte, l'instruction suivante “passe” à l'instruction séquentielle suivante ou aux branches à l'extérieur de la boucle.

Il existe principalement deux types de boucles:

  •   Boucles à entrée contrôlée: dans ce type de boucles, la condition est testée avant d'entrer dans le corps de la boucle. boucle for et boucle while sont des boucles d'entrée contrôlées.
  •   Boucles à sortie contrôlée: dans ce type de boucles, la condition est testée ou évaluée à l'extrémité du corps de la boucle. Par conséquent, le corps de boucle s'exécutera au moins une fois, que la condition soit true ou false. do-while est une boucle de sortie contrôlé.

boucle for

Une boucle for est une structure de contrôle répétitive qui vous permet d'écrire efficacement une boucle devant être exécutée un nombre de fois spécifique.

Une boucle for est utile lorsque vous savez combien de fois une tâche doit être répétée.

Syntaxe :
                                for(initialisation ; condition ; mise à jour){
                                    // bloc d'instructions à répéter
                                }
                            

Dans la boucle for, une variable de boucle est utilisée pour contrôler la boucle.
Commencez par initialiser cette variable de boucle sur une valeur(initialisation), puis vérifiez si cette variable est inférieure ou supérieure à la valeur du compteur (condition). Si l'instruction est vraie, le corps de la boucle est exécuté et sa variable est mise à jour (mise à jour). Les étapes sont répétées jusqu'à la condition de sortie.

Exemple 1 :
                                public class Test{

                                    public static void main(String args[]){

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

                                    return 0;
                                }
                            
i = 0
i = 1
i = 2
i = 3
i = 4
  •   Initialisation: Dans cette expression, nous devons initialiser le compteur de boucle à une valeur. par exemple: i = 1;
  •   condition: Dans cette expression, nous devons tester la condition. Si la condition est true, nous exécuterons le corps de la boucle et mettrons à jour l'expression, sinon nous sortirons de la boucle for. Par exemple: i <=5;
  •   mise à jour : après avoir exécuté le corps de la boucle, cette expression incrémente / décrémente la variable de la boucle d'une valeur. par exemple: i++;

boucle for améliorée

Java inclut également une autre version de for loop introduite dans Java 5. boucle for-each fournit un moyen plus simple de parcourir les éléments d'une collection ou d'un tableau. Il est inflexible et ne doit être utilisé que lorsqu'il est nécessaire de parcourir les éléments de manière séquentielle sans connaître l'index de l'élément en cours de traitement.

Syntaxe :
                                for (elem : Collection/Tableau) 
                                { 
                                    // traitements sur elem
                                }
                            

La nouvelle variable de bloc déclarée "elem" est d'un type compatible avec les éléments du tableau auquel vous accédez. La variable sera disponible dans le bloc for et sa valeur sera identique à celle de l'élément de tableau actuel.

Collection/Tableau : Cela correspond au tableau que vous devez parcourir en boucle. L'expression peut être une variable de tableau ou un appel à une méthode renvoyant un tableau.

Exemple 2 :
                                public class Test{
                                    
                                    public static void main(String args[]){
                                    
                                        int[] T={3, 6, 7, 2, 1};

                                        for(int elem : T){
                                            System.out.println(elem);
                                        }
                                    }
                                }
                            
3
6
7
2
1
Limitations de la boucle for-each
  •   Les boucles For-each ne conviennent pas lorsque vous souhaitez modifier le tableau:
  •   Les boucles For-each ne gardent pas trace de l'index.
  •   "for-each" itère seulement en avant sur le tableau avec un seul pas

boucle while

Une instruction de boucle while en langage de programmation Java exécute de manière répétée une instruction cible tant qu'une condition donnée est vraie.

Syntaxe :
                                initialisation
                                while(condition){

                                    // corps de la bucle

                                    mise à jour
                                }
                            
Exemple 3 :
                                public class Test{
                                    
                                    public static void main(String args[]){
                                        int i;
                                        i=0; // initialisation
                                        while(i < 5){  // condition
                                            System.out.println("i = " + i);

                                            i++; // mise à jour
                                        }

                                    }
                                }
                            
i = 0
i = 1
i = 2
i = 3
i = 4

Ici, le point clé de la boucle while est que la boucle peut ne jamais être exécutée. Lorsque l'expression est testée et que le résultat est false, le corps de la boucle est ignoré et la première instruction après la boucle while est exécutée.

boucle do-while

Une boucle do ... while est similaire à une boucle while, sauf qu'une boucle do ... while est garantie pour être exécutée au moins une fois parce que la condition est testée à la fin du corps de la boucle;

Syntaxe :
                                initialisation
                                do{
                                    // corps de la bucle

                                    mise à jour
                                }while(condition);
                            
Notez le point-virgule (;) à la fin de la boucle.
Exemple 4 :
                                public class Test{
                                    
                                    public static void main(String args[]){
                                        int i;
                                        i=0; // initialisation
                                        do{  
                                            System.out.println("i = " + i);

                                            i++; // mise à jour
                                        }while(i < 5);// condition

                                    }
                                }
                            
i = 0
i = 1
i = 2
i = 3
i = 4

Les points importants

  •   Utilisez la boucle for lorsque le nombre d'itérations est connu à l'avance, c'est-à-dire que le nombre de fois que le corps de la boucle doit être exécuté est connu.
  •   Utilisez les boucles while pour lesquelles le nombre exact d'itérations n'est pas connu mais la condition de fin de boucle est connue.
  •   Utilisez la boucle do while si le code doit être exécuté au moins une fois, comme dans les programmes pilotés par le menu.

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :