Comment écrire une boucle for en Java »wiki utile
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 apprenez. Il existe de nombreux types de boucles, mais les boucles for sont sans doute l'une des boucles les plus utiles.
La boucle For à Java
Les boucles For continueront d'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. Donc, 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 familiarisé avec Java, il est recommandé de lire un didacticiel pour débutants avant d'apprendre des sujets avancés tels que les boucles for.
for([statement1]; [condition]; [statement2]){
//code to execute each loop
}Le mot-clé for indique une boucle for. La condition qui détermine la durée de la boucle se trouve entre les crochets. 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 l' instruction1 et la condition. 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.
public class Main{
public static void main(String[] args) {
for(int i = 1; i < 4; i++){
System.out.print(i);
}
}
}
//Output: 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éfinie sur 1. La condition vérifie si i est égal ou supérieur à quatre. Ce n'est pas le cas, donc notre boucle est exécutée. Le code de boucle imprime la valeur de i , qui est toujours 1 à ce stade. Une fois le code de boucle terminé, i est incrémenté de un et la boucle recommence. A la fin de la troisième boucle, i est augmenté à quatre. Lorsque la boucle suivante commence, notre condition est remplie, donc la boucle s'arrête.
Boucle For imbriquée
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 compteur i générique, l'utilisation de compteurs génériques devient déroutant lorsque plusieurs boucles interagissent.
for(int lineCounter = 1; lineCounter < 4; lineCounter++){
for(int starCounter = 1; starCounter <= lineCounter; starCounter++){
System.out.print("*");
}
System.out.print("n");
}Passons en revue cet exemple pour mieux comprendre son fonctionnement. Notre première boucle compte le nombre de lignes que nous créons. Une fois la boucle exécutée trois fois, elle s'arrêtera. La prochaine boucle 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.
Boucles infinies
L'un des dangers du codage de tout 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 y ait des cas où une boucle infinie est nécessaire, généralement, ils sont créés 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:
for(;;){
//code that never stops looping
}
Utilisation d'une boucle For avec un tableau
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 afficherait 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[] words = {"Hello", " ", "World", "!"};
for(int i = 0; i < words.length; i ++){
System.out.print(words[i]);
}Rappelez-vous que les positions de tableau commencent à zéro, pas à un, donc nous voulons que notre boucle commence à zéro. Notre première boucle imprimera Hello , 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.
Production:
Hello World!Pour chaque boucle
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 tableaux. Un pour chaque boucle passera par chaque élément d'un tableau et exécutera le 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 to be executed
}Notre exemple précédent peut être réécrit comme une boucle for-each en utilisant cette syntaxe:
String[] words = {"Hello", " ", "World", "!"};
for(String word : words){
System.out.print(word);
}La boucle est lancé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 itérons dans la boucle. Dans ce cas, nous avons utilisé word . Ceci est suivi de deux points et du nom du tableau que nous voulons parcourir. Maintenant, dans notre boucle, nous devons simplement utiliser le mot variable pour faire référence à chaque élément du tableau.
Quand utiliser une boucle For
Les boucles For sont d'excellents outils qui peuvent vous faire économiser beaucoup de codage. Il s'agit du 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 est sûre de vous éviter de coder du code répétitif inutile.