Les boucles sont des outils de programmation très puissants qui complètent un ensemble d'instructions jusqu'à ce qu'une condition soit remplie. Ils sont très pratiques et devraient être l'un des premiers concepts de programmation que vous apprendrez. Il existe de nombreux types de boucles, mais for les boucles sont sans doute l'une des boucles les plus utiles.
Les boucles for continueront à exécuter un bloc de code jusqu'à ce qu'une condition soit remplie. Il est important de noter qu'une boucle for vérifiera la condition au début de la boucle, pas à la fin. Cela signifie que si la condition est remplie, la boucle ne démarrera pas.
La syntaxe de la boucle For est similaire dans tous les langages de programmation. Ainsi, si vous avez créé une boucle for dans un autre langage de programmation, une boucle for Java vous semblera familière. Cependant, si vous n'êtes pas du tout familier avec Java, il est recommandé de lire un didacticiel pour débutants avant d'apprendre des sujets avancés comme les boucles for.
pour([instruction1] ; [condition] ; [instruction2]){
//code pour exécuter chaque boucle
} Le mot clé pour indique une boucle for. La condition qui détermine la durée de la boucle est située entre parenthèses.
La première instruction est exécutée une fois lorsque la boucle for est lancée; la condition définit quand la boucle doit s'arrêter.
La deuxième instruction est exécutée à la fin de chaque boucle. Les points-virgules marquent la fin de statement1 et l'état.
En règle générale, les instructions sont utilisées pour créer un compteur et la condition arrête la boucle une fois que le compteur atteint un nombre spécifique. Enfin, le code exécuté dans chaque boucle est placé entre les accolades.
classe publique Main{
public static void main(String[] args) {
pour(int je =1; je <4; je++){
System.out.print(i);
}
}
}
//Sortie :123
Dans l'exemple ci-dessus, la boucle for imprime la valeur de i . Le mot clé pour initialise la boucle. La variable i est initialement défini sur 1. La condition vérifie si i est de quatre ou plus. Ce n'est pas le cas, donc notre boucle est exécutée. Le code de la boucle imprime la valeur de i , qui vaut toujours 1 à ce stade.
Une fois le code de la boucle terminé, i est incrémenté de un et la boucle recommence. A la fin de la troisième boucle, i est portée à quatre. Lorsque la boucle suivante commence, notre condition est remplie, donc la boucle s'arrête.
Une fois que vous maîtrisez une boucle for, vous devriez essayer de créer une boucle for imbriquée. C'est quand vous avez une boucle for à l'intérieur d'une autre boucle for. Il s'agit d'une technique avancée car il peut être difficile de comprendre comment les deux boucles vont interagir. Un bon moyen de visualiser le fonctionnement des boucles for imbriquées consiste à créer le modèle suivant avec une boucle for imbriquée.
*
**
*** Pour créer cela, nous aurons besoin d'une boucle pour contrôler le nombre d'étoiles imprimées sur chaque ligne et d'une autre boucle pour contrôler le nombre de lignes à créer. Lorsque vous débutez avec les boucles for imbriquées, il peut être difficile de déterminer quelle boucle est la boucle interne. Dans ce cas, la boucle qui imprime les étoiles est la boucle intérieure. Nous avons besoin que cette boucle s'exécute à chaque fois qu'une nouvelle ligne est créée.
Lors de la création d'une boucle imbriquée, soyez prudent lorsque vous choisissez le nom de vos variables de compteur. Bien que les programmeurs utilisent souvent un i générique compteur, l'utilisation de compteurs génériques devient déroutante lorsque plusieurs boucles interagissent.
for(int lineCounter =1; lineCounter <4; lineCounter++){
for(int starCounter =1; starCounter <=lineCounter; starCounter++){
System.out.print("*");
}
System.out.print("
");
} Passons en revue cet exemple pour mieux comprendre comment cela fonctionne.
Notre première boucle compte le nombre de lignes que nous faisons. Après que la boucle s'exécute trois fois, elle s'arrêtera.
La boucle suivante est un peu plus complexe. Cette boucle contrôle le nombre d'étoiles imprimées sur chaque ligne. Dans notre modèle, nous voulons le même nombre d'étoiles que le numéro de ligne. La première ligne a une étoile, la deuxième deux et la troisième trois. Donc, nous voulons que cette boucle imprime autant d'étoiles que notre compteur de lignes actuel.
Une fois notre boucle en étoile terminée, la boucle de ligne crée une nouvelle ligne en imprimant \n , qui est la commande pour une nouvelle ligne.
L'un des dangers du codage de n'importe quel type de boucle est que vous pouvez accidentellement créer une boucle infinie. Ce sont des boucles qui ne s'arrêtent jamais. Bien qu'il existe des cas où une boucle infinie est nécessaire, elles sont généralement créées par accident lorsque la condition de la boucle n'est pas soigneusement planifiée. Dans ces cas, le programme continuera à s'exécuter jusqu'à ce que vous le forciez à se fermer.
Pour créer une boucle infinie, vous pouvez utiliser la syntaxe suivante :
pour(;;){
//code qui n'arrête jamais de boucler
} Une façon courante d'utiliser une boucle for consiste à parcourir un tableau. Par exemple, si vous souhaitez imprimer toutes les chaînes d'un tableau, vous ne pouvez pas simplement dire
System.out.print([array]); Cette commande imprimerait des informations sur le tableau, pas le contenu du tableau. Pour imprimer le contenu du tableau, vous devez imprimer chaque élément individuel du tableau. Cela prendrait du temps à coder, mais vous pourriez créer une boucle for pour parcourir chaque élément.
String[] mots ={"Bonjour", " ", "Monde", "!"} ;
for(int je =0; je System.out.print(mots[i]);
} N'oubliez pas que les positions du tableau commencent à zéro, pas à un, nous voulons donc que notre boucle commence à zéro. Notre première boucle affichera Bonjour , la deuxième boucle imprimera un espace, et ainsi de suite. Après la quatrième boucle, notre compteur sera incrémenté à quatre, ce qui n'est pas inférieur à la longueur du tableau, qui est également de quatre. Cela arrêtera la boucle.
Sortie :
Salut le monde ! Bien que vous puissiez utiliser une boucle for pour parcourir un tableau, il est plus facile d'utiliser une boucle for-each. Ces boucles sont conçues spécifiquement pour les baies. Une boucle pour chaque parcourra chaque élément d'un tableau et exécutera du code. Les boucles for-each ont une syntaxe légèrement différente. Le mot clé pour est toujours utilisé, mais aucune condition n'est spécifiée.
for([dataType] [arrayElement] :[array]){
//code à exécuter
} Notre exemple précédent peut être réécrit comme une boucle for-each en utilisant cette syntaxe :
String[] mots ={"Bonjour", " ", "Monde", "!"} ;
for(String mot :mots){
System.out.print(mot);
} La boucle est démarrée avec le mot-clé for . Nous spécifions ensuite que les données de notre tableau sont des chaînes. Ensuite, nous choisissons un nom de variable pour faire référence aux éléments du tableau lorsque nous parcourons la boucle. Dans ce cas, nous avons utilisé mot . Ceci est suivi de deux-points et du nom du tableau que nous voulons parcourir. Maintenant, à l'intérieur de notre boucle, nous n'avons plus qu'à utiliser la variable word pour faire référence à chaque élément du tableau.
Les boucles for sont d'excellents outils qui peuvent vous faire économiser beaucoup de codage. C'est le meilleur type de boucle à utiliser lorsque vous savez exactement combien de fois vous voulez que votre boucle s'exécute. Vous pouvez même augmenter la complexité des boucles for en les imbriquant.
Les boucles for imbriquées sont particulièrement pratiques lorsque vous travaillez avec des tableaux multidimensionnels. Les boucles for sont faciles à apprendre et constituent une compétence importante pour les débutants. Cette technique vous évitera certainement de coder du code répétitif inutile.