Je ne suis pas doué pour toujours.
Le traitement itératif est également appelé ** boucle **, et il existe à peu près trois types d'instructions itératives: ** instruction while **, ** instruction do-while ** et ** for statement **.
L'instruction ** while ** itère pendant que la condition spécifiée est remplie (le résultat de l'expression conditionnelle est vrai).
Sample.java
while (Expression conditionnelle) {
Déclaration de processus; //L'instruction de traitement est exécutée lorsque le résultat de l'expression conditionnelle est vrai
}
S'il n'y a qu'une seule instruction de traitement, vous pouvez omettre {}. L'expression conditionnelle est décrite dans () après while. L'expression conditionnelle doit être une expression qui a une valeur booléenne (vrai ou faux). Si le résultat du jugement de condition est vrai, l'instruction de traitement incluse dans {} est exécutée. L'instruction de traitement peut être décrite sur plusieurs lignes. Après l'exécution de l'instruction de traitement, le contrôle est à nouveau transféré vers l'expression conditionnelle.
Sample.java
public class Sample {
public static void main(String[] args) {
int num = 0;
while (num < 5) { //Répéter tant que la valeur num est inférieure à 5
System.out.print(num + " ");
num++; //Ajouter 1 à la valeur de num
}
}
}
[Résultat de l'exécution] 0 1 2 3 4
Le traitement itératif est effectué tandis que l'expression conditionnelle renvoie true. Lorsque l'expression conditionnelle renvoie false, le processus itératif se termine et l'instruction while se termine.
L'instruction ** do-while ** répète le processus tant que la condition spécifiée est satisfaite (true), comme l'instruction while.
Sample.java
do {
Déclaration de processus;
} while (Expression conditionnelle);
Tout d'abord, écrivez l'instruction de traitement en la plaçant entre {} après do. Après cela, écrivez l'expression conditionnelle entre () après while. Comme l'instruction while, l'expression conditionnelle doit être une expression qui a une valeur booléenne (true ou false). Tant que le jugement de condition est vrai, le traitement itératif est exécuté, et lorsque le jugement de condition devient faux, l'instruction do-while se termine. Comme pour l'instruction while, {} peut être omis s'il n'y a qu'une seule instruction de traitement. La différence avec l'instruction while est que l'instruction while effectue d'abord le jugement de condition, puis démarre le processus itératif, tandis que l'instruction do-while exécute d'abord le processus itératif, puis le jugement de condition.
Sample.java
public class Sample {
public static void main(String[] args) {
int num = 0;
do { //Exécution d'un traitement itératif
System.out.print(num + " ");
num++; //Ajouter 1 à la valeur de num
} while (num < 5); //Si le nombre de jugement de condition est inférieur à 5
}
}
[Résultat de l'exécution] 0 1 2 3 4
Comme mentionné ci-dessus, la différence entre l'instruction while et l'instruction do-while est le moment auquel le jugement de condition est effectué. Selon les conditions, l'instruction while peut ne jamais être traitée dans le bloc. D'autre part, l'instruction do-while a un bloc do avant le jugement de condition, donc l'instruction de traitement sera exécutée une fois quelle que soit la condition.
Il existe une instruction ** for ** comme troisième instruction à traiter de manière itérative. Dans l'instruction while et l'instruction do-while, seule l'expression conditionnelle était décrite dans (), mais dans l'instruction for, la variable count indiquant le nombre de répétitions et la mise à jour de la variable count sont également décrites dans ().
Sample.java
for (Équation 1;Équation 2;Équation 3;) {
Déclaration de processus;
}
L'équation 1 déclare et initialise une variable qui indique le nombre d'itérations. Cette variable est parfois appelée la ** variable de compteur **. Cette expression 1 n'est exécutée qu'une seule fois pour la première fois. Une expression conditionnelle est décrite dans Expression 2. Le résultat conditionnel, comme toute autre instruction itérative, doit être une expression qui a une valeur booléenne. Tant que le jugement de condition est vrai, le traitement itératif est exécuté et lorsque le jugement de condition devient faux, l'instruction for se termine. L'expression 3 décrit une expression qui met à jour la valeur de la variable de compteur. Si l'instruction à traiter n'a qu'une minute, {} peut être omis.
Sample.java
public class Sample {
public static void main(String[] args) {
for (int count=0; count<5; count++) {
System.out.println(count + " ");
}
}
}
[Résultat de l'exécution] 0 1 2 3 4
De plus, l'équation 1, l'équation 2 et l'équation 3 décrites dans () pour for peuvent être omises respectivement. Si l'expression conditionnelle, expression 2, est omise, la condition est toujours déterminée comme vraie, ce qui entraîne une boucle infinie.
Sample.java
public class Sample {
public static void main(String[] args) {
int count1 = 0;
for (; count1<5; count1++) { //Exemple d'omission de l'équation 1
System.out.print(count1 + " ");
}
System.out.println(); //nouvelle ligne
for (int count2=0; count2<5;) { //Exemple d'omission de l'équation 3
System.out.print(count2 + " ");
}
}
}
[Résultat de l'exécution] 0 1 2 3 4 0 1 2 3 4
Dans le langage Java, ** extended for statement ** est fourni comme une instruction pratique. Ceci est utilisé lorsque tous les éléments de ** array ** et ** collection ** sont extraits et traités dans l'ordre, et que la description est simplifiée par rapport à l'instruction for.
Sample.java
for (Déclaration de variable:Nom de la variable de référence) {
Déclaration de processus;
}
L'instruction for extended extrait les éléments dans l'ordre de la variable de référence spécifiée dans () et affecte les éléments extraits aux variables déclarées dans la déclaration de variable. Par conséquent, le type de données ** de la variable déclarée dans la déclaration de variable doit correspondre au ** type de chaque élément ** de la variable de référence. L'instruction for étendue se termine lorsque tous les éléments ont été extraits de la variable de référence.
Sample.java
public class Sample {
public static void main(String[] args) {
//Déclaration de tableau
char[] array = {'a', 'b', 'c', 'd', 'e'};
//Extrait tous les éléments du tableau dans l'ordre et les produit
for (char c : array) { //Lors du traitement avec l'instruction for Extended
System.out.print(c + " ");
}
System.out.println(); //nouvelle ligne
//Lors du traitement avec une instruction for
for (int count=0; count<array.length; count++) {
System.out.print(count + " ");
}
}
}
[Résultat de l'exécution] a b c d e a b c d e
La prochaine fois sur les déclarations de contrôle.
Recommended Posts