Les Boucles en Java
1. Des boucles en Java
Dans la programmation informatique (computer programming), une boucle est régulièrement utilisée et le but est d'exécuter un programme à plusieurs reprises. Java prend en charge 3 types de boucles différentes :
- La boucle for
- La boucle while
- La boucle do-while
La boucle for a 2 variantes:
- La boucle for commune.
- La boucle for-each (Ajoutée à partir de version Java 5).
Les instructions peuvent être utilisées dans la boucle :
- break
- continue.
2. La boucle for
Syntaxe :
** for **
// start_value: Valeur initiale
// end_value: Valeur finale
// increment_number: La valeur augmente après chaque étape de l'itération.
for ( start_value; end_value; increment_number ) {
// Faites quelque chose ici ...
}
Considérez une illustration :
ForLoopExample1.java
package org.o7planning.tutorial.javabasic.loop;
public class ForLoopExample1 {
public static void main(String[] args) {
// Déclarez une variable 'step', décrivant l'étape de la boucle (quelle boucle)
int step = 1;
// Déclarez une variable 'value' avec la valeur initiale est 0
// Après chaque itération 'value', la valeur augmentera 3
// Et la boucle se terminera lorsque la valeur supérieure ou égale à 10
for (int value = 0; value < 10; value = value + 3) {
System.out.println("Step =" + step + " value = " + value);
// Augmentez la valeur 'step' jusqu'à 1, après chaque itération
step = step + 1;
}
}
}
Les résultats d'exécution de la classe ForLoopExample1 :
Step =1 value = 0
Step =2 value = 3
Step =3 value = 6
Step =4 value = 9
Observez un autre exemple, calculez la somme des nombres de 1 à 100 :
ForLoopExample2.java
package org.o7planning.tutorial.javabasic.loop;
public class ForLoopExample2 {
// Ceci est un exemple pour compter la totalité des nombres de 1 à 100,
// et imprimez les résultats sur console.
public static void main(String[] args) {
// Déclarez une variable
int total = 0;
// Déclarez une variable 'value'
// Assignez une valeur initiale 1
// Après chaque itération, sa valeur augmente 1
// Remarque : la valeur ++ équivaut à l'instruction : valeur = valeur + 1 ;
// value-- équivaut à l'instruction : value = value - 1;
for (int value = 1; value <= 100; value++) {
// Assignez la valeur 'total' à l'ancienne valeur plus 'valeur'.
total = total + value;
}
System.out.println("Total = " + total);
}
}
Résultats
Total = 5050
3. La boucle for-each
La boucle for-each est ajoutée en Java à partir de la version 5. Une boucle est utilisée pour traverser (traverse) un tableau ou une collection, elle se déplacera respectivement du premier élément au dernier élément d'un tableau ou une collection.
Voyez plus :
Syntaxe:
// arrayOrCollection : Tableau ou Collection (Collection).
for (Type variable: arrayOrCollection) {
// Code ...
}
Exemple :
ForeachExample.java
package org.o7planning.tutorial.javabasic.loop;
public class ForeachExample {
public static void main(String[] args) {
// Déclarez un tableau de String.
String[] fruits = new String[] { "Apple", "Apricot", "Banana" };
// Utilisez la boucle for-each pour traverser les éléments du tableau.
for (String fruit : fruits) {
System.out.println(fruit);
}
}
}
Exécutez l'exemple :
Apple
Apricot
Banana
4. La boucle while
La boucle while est utilisée pour exécuter plusieurs fois un segment de programme, quand une condition est toujours true. La boucle while est généralement utilisée lorsque le nombre d'itérations ne peut être déterminé avant (non fixé).
Ceci est la structure de boucle while :
** while **
// Lorsque la condition (condition) est vraie, alors faites quelque chose
while ( condition ) {
// Faites quelque chose...
}
Voyez un exemple d'illustration :
WhileExample1.java
package org.o7planning.tutorial.javabasic.loop;
public class WhileExampe1 {
public static void main(String[] args) {
int value = 3;
// Lorsque la 'valeur' est encore inférieur à 10, la boucle fonctionne toujours.
//
while (value < 10) {
System.out.println("Value = " + value);
// Augmentez la ''valeur'' en ajoutant 2
value = value + 2;
}
}
}
5. La boucle do-while
La boucle do-while est utilisée pour exécuter un segment de programme plusieurs fois. Les caractéristiques de do-while est un bloc de commande qui est toujours exécuté au moins une fois. Après l'itération (iteration), le programme vérifie la condition, si la condition est toujours vraie, le bloc de commande sera encore exécuté.
Ceci est la structure de boucle do-while :
** do while **
// La boucle de do-while effectue au moins une itération (iteration)
// Et lorsque la condition est vraie, elle continue de fonctionner
do {
// Faites quelque chose ici.
}
while (condition);
L'exemple d'illustration :
DoWhileExample1.java
package org.o7planning.tutorial.javabasic.loop;
public class DoWhileExample1 {
public static void main(String[] args) {
int value = 3;
// La boucle do-while exécutera au moins une fois.
do {
System.out.println("Value = " + value);
// Augmentez la ''valeur'' en ajoutant 3
value = value + 3;
} while (value < 10);
}
}
Résultats :
Value = 3
Value = 6
Value = 9
6. L'instruction break dans la boucle
L'instruction break peut apparaître dans une boucle. C'est l'instruction qui aide le programme à sortir de la boucle.
Exemple :
LoopBreakExample.java
package org.o7planning.tutorial.javabasic.loop;
public class LoopBreakExample {
public static void main(String[] args) {
System.out.println("Break example");
int x = 2;
while (x < 15) {
System.out.println("----------------------\n");
System.out.println("x = " + x);
// Vérifiez si x = 5 puis quittez la boucle.
if (x == 5) {
break;
}
x++;
System.out.println("x after ++ = " + x);
}
System.out.println("Done!");
}
}
L'exécution l'exemple :
Break example
----------------------
x = 2
x after ++ = 3
----------------------
x = 3
x after ++ = 4
----------------------
x = 4
x after ++ = 5
----------------------
x = 5
Done!
7. L'instruction continue dans une boucle
L'instruction continue peut apparaître dans une boucle. Lorsque le programme attrape une instruction continue,il ignore les instructions à l'intérieur du bloc et le bas de l'instruction continue et entame une nouvelle itération (si les conditions sont vraies. ).
Exemple :
LoopContinueExample.java
package org.o7planning.tutorial.javabasic.loop;
public class LoopContinueExample {
public static void main(String[] args) {
System.out.println("Continue example");
int x = 2;
while (x < 7) {
System.out.println("----------------------\n");
System.out.println("x = " + x);
// x = x + 1;
x++;
// % operator is used for calculating remainder.
// If x is even, then ignore the command line below of 'continue',
// and start new iteration (if condition still true).
if (x % 2 == 0) {
continue;
}
System.out.println("x after ++ = " + x);
}
System.out.println("Done!");
}
}
Exécutez l'exemple :
Continue example
----------------------
x = 2
x after ++ = 3
----------------------
x = 3
----------------------
x = 4
x after ++ = 5
----------------------
x = 5
----------------------
x = 6
x after ++ = 7
Done!
8. La boucle à étiquette (Labelled Loop)
Java vous permet de coller une étiquette (Label) à une boucle, comme vous le feriez pour nommer une boucle, ce qui est utile lorsque vous utilisez des boucles imbriquées dans un programme.
- Vous pouvez utiliser l'instruction break labelX; Pour break la boucle à étiquette labelX.
- Vous pouvez utiliser l'instruction continue labelX; Pour continue la boucle à étiquette labelX.
Syntaxe :
** Labelled Loops **
// La boucle à étiquette (Label)
label1: for( ... ) {
}
// La boucle à étiquette (Label)
label2: while ( ... ) {
}
// La boucle do-while à étiquette (Label)
label3: do {
} while ( ... );
L'exemple d'utilisation des boucles imbriquées, des boucles à étiquette et des instructions break à étiquette
LabelledLoopBreakExample.java
package org.o7planning.tutorial.javabasic.loop;
public class LabelledLoopBreakExample {
public static void main(String[] args) {
System.out.println("Labelled Loop Break example");
int i = 0;
label1: while (i < 5) {
System.out.println("----------------------\n");
System.out.println("i = " + i);
i++;
label2: for (int j = 0; j < 3; j++) {
System.out.println(" --> " + j);
if (j > 0) {
// Quittez la boucle avec label1.
break label1;
}
}
}
System.out.println("Done!");
}
}
Exécutez l'exemple :
Labelled Loop Break example
----------------------
i = 0
--> 0
--> 1
Done!
L'exemple d'utilisation des boucles imbriquées et d'utilisation l'instruction étiquetée continue
LabelledLoopContinueExample.java
package org.o7planning.tutorial.javabasic.loop;
public class LabelledLoopContinueExample {
public static void main(String[] args) {
System.out.println("Labelled Loop Continue example");
int i = 0;
label1: while (i < 5) {
System.out.println("outer i= " + i);
i++;
label2: for (int j = 0; j < 3; j++) {
if (j > 0) {
continue label2;
}
if (i > 1) {
continue label1;
}
System.out.println("inner i= " + i + ", j= " + j);
}
}
}
}
Exécutez l'exemple :
Labelled Loop Continue example
outer i= 0
inner i= 1, j= 0
outer i= 1
outer i= 2
outer i= 3
outer i= 4
Java Basic
- Personnaliser le compilateur Java pour traiter votre annotation (Annotation Processing Tool)
- Programmation Java pour l'équipe utilisant Eclipse et SVN
- Le Tutoriel de Java WeakReference
- Le Tutoriel de Java PhantomReference
- Tutoriel sur la compression et la décompression Java
- Configuration d'Eclipse pour utiliser le JDK au lieu de JRE
- Méthodes Java String.format() et printf()
- Syntaxe et nouvelles fonctionnalités de Java 8
- Expression régulière en Java
- Tutoriel de programmation Java multithreading
- Bibliothèques de pilotes JDBC pour différents types de bases de données en Java
- Tutoriel Java JDBC
- Obtenir des valeurs de colonne automatiquement incrémentées lors de l'insertion d'un enregistrement à l'aide de JDBC
- Le Tutoriel de Java Stream
- Le Tutoriel de Java Functional Interface
- Introduction à Raspberry Pi
- Le Tutoriel de Java Predicate
- Classe abstraite et interface en Java
- Modificateurs d'accès en Java
- Le Tutoriel de Java Enum
- Le Tutoriel de Java Annotation
- Comparer et trier en Java
- Le Tutoriel de Java String, StringBuffer et StringBuilder
- Tutoriel de gestion des exceptions Java
- Le Tutoriel de Java Generics
- Manipulation de fichiers et de répertoires en Java
- Le Tutoriel de Java BiPredicate
- Le Tutoriel de Java Consumer
- Le Tutoriel de Java BiConsumer
- Qu'est-ce qui est nécessaire pour commencer avec Java?
- L'histoire de Java et la différence entre Oracle JDK et OpenJDK
- Installer Java sur Windows
- Installer Java sur Ubuntu
- Installer OpenJDK sur Ubuntu
- Installer Eclipse
- Installer Eclipse sur Ubuntu
- Le Tutoriel Java pour débutant
- Histoire des bits et des bytes en informatique
- Types de données dans Java
- Opérations sur les bits
- Le Tutoriel de instruction Java If else
- Le Tutoriel de instruction Java Switch
- Les Boucles en Java
- Les Tableaux (Array) en Java
- JDK Javadoc au format CHM
- Héritage et polymorphisme en Java
- Le Tutoriel de Java Function
- Le Tutoriel de Java BiFunction
- Exemple de Java encoding et decoding utilisant Apache Base64
- Le Tutoriel de Java Reflection
- Invocation de méthode à distance en Java
- Le Tutoriel de Java Socket
- Quelle plate-forme devez-vous choisir pour développer des applications de bureau Java?
- Le Tutoriel de Java Commons IO
- Le Tutoriel de Java Commons Email
- Le Tutoriel de Java Commons Logging
- Comprendre Java System.identityHashCode, Object.hashCode et Object.equals
- Le Tutoriel de Java SoftReference
- Le Tutoriel de Java Supplier
- Programmation orientée aspect Java avec AspectJ (AOP)
Show More
- Tutoriels de programmation Java Servlet/JSP
- Tutoriels de Java Collections Framework
- Tutoriels Java API pour HTML & XML
- Tutoriels Java IO
- Tutoriels Java Date Time
- Tutoriels Spring Boot
- Tutoriels Maven
- Tutoriels Gradle
- Tutoriels Java Web Service
- Tutoriels de programmation Java SWT
- Tutoriels de JavaFX
- Tutoriels Java Oracle ADF
- Tutoriels Struts2
- Tutoriels Spring Cloud