Pour ceux qui viennent de commencer à apprendre la programmation, y compris le langage Java, et ceux qui l'ont déjà appris, pour examen Cette fois, j'écris pour en savoir plus sur le ** traitement itératif et les instructions de contrôle itératives **.
Il s'agit de répéter un certain processus en spécifiant le nombre de fois et «tant que la condition est satisfaite».
python
int a = 0;
System.out.println("a => " + a);
a += 1;
System.out.println("a => " + a);
a += 1;
System.out.println("a => " + a);
Il est possible de décrire clairement une série de processus tels que la sortie d'un comme décrit ci-dessus, +1 et la sortie à nouveau par un traitement itératif.
Le traitement itératif est également appelé ** boucle **, et cet article traite de instruction while, instruction do-while, instruction for et instruction étendue for.
** Tant que la condition spécifiée est remplie (vraie) **, le processus est répété.
syntaxe
while(Expression conditionnelle) {
Déclaration de processus; //Exécuté si l'expression conditionnelle est vraie
}
L'expression conditionnelle après while doit être une expression qui renvoie une valeur booléenne (vrai, faux).
exemple d'instruction while
int num = 0;
while(num < 5) {
System.out.println("num => " + num);
num++;
}
Résultat d'exécution
num => 0
num => 1
num => 2
num => 3
num => 4
Il est possible de décrire clairement une série de traitements tels que la sortie de la variable apparue au début, +1 et la sortie à nouveau.
Ce processus est répété tant que num est inférieur à 5, quand ** num incrémenté par boucle devient 5, **,
Puisque false est renvoyé lorsque la condition est jugée, l'instruction while se termine.
Le processus itératif peut continuer à être exécuté sans s'arrêter. Veuillez noter les points suivants.
Exemple de boucle infinie 1
int num = 0;
while(num < 5) {
System.out.println("num => " + num);
num++;
}
S'il n'y a pas de description de num ++ dans ce code, la variable num reste 0.
L'expression conditionnelle num <5 continue de renvoyer true, ce qui entraîne une ** boucle infinie **.
Exemple de boucle infinie 2
int num = 0;
while(true) {
System.out.println("num => " + num);
num++;
}
Ensuite, si vous faites «while (true)» dans l'expression conditionnelle. Ceci est également toujours renvoyé comme vrai, ce qui entraîne une ** boucle infinie **.
La ** instruction de contrôle de répétition ** utilisée pour empêcher une boucle infinie (pour sortir de la boucle) sera expliquée dans un article séparé. Souvenons-nous de cela aussi.
Mauvais exemple
while(false) {
//En traitement
}
Si l'expression conditionnelle est «while (false)», une erreur de compilation se produira car le processus ne peut pas être démarré.
Dans certains cas, rien n'est produit même si aucune erreur ne se produit.
Exemple d'absence de sortie
int num = 0;
while(num > 0) {
System.out.println("num => " + num);
num--;
}
Aucune sortie du résultat d'exécution ci-dessus n'est sortie. C'est parce qu'il compare si la condition while est supérieure à 0, donc false est soudainement renvoyé et le processus se termine sans entrer dans la boucle.
Si la variable num est définie sur 1 ou plus, le traitement à l'intérieur de la boucle sera exécuté.
Plan d'amélioration
int num = 3;
while(num > 0) {
System.out.println("num => " + num);
num--;
}
Résultat d'exécution
num => 3
num => 2
num => 1
Comme pour l'instruction while, itère sur ** pendant que la condition spécifiée est remplie (true) **.
syntaxe
do {
Déclaration de processus;
}while(Expression conditionnelle);
Semblable à l'instruction while, l'expression conditionnelle doit être une expression qui renvoie une valeur booléenne (vrai, faux).
do-exemple d'instruction while
int num = 0;
do {
System.out.println("num => " + num);
num++;
}while(num < 5);
Résultat d'exécution
num => 0
num => 1
num => 2
num => 3
num => 4
Ce processus est répété tant que num est inférieur à 5, quand ** num incrémenté par boucle devient 5, **,
L'instruction do-while se termine car false est renvoyé lorsque la condition est jugée.
Le moment auquel le jugement de condition est effectué est différent.
Dans l'instruction while, la condition est jugée ** en premier **, de sorte que le processus ne peut pas être exécuté comme décrit ci-dessus. Cependant, dans l'instruction do-while, il y a un bloc do avant le jugement de condition **, et le jugement de condition est effectué après **. Par conséquent, le processus est exécuté une fois quelles que soient les conditions.
Exemple de jugement de condition_while
int num = 0;
while(num > 0) {
System.out.println("while_num => " + num);
num--;
}
Rien n'est produit dans l'instruction while ci-dessus.
Exemple de jugement de condition_do-while
int num = 0;
do {
System.out.println("do-while_num => " + num);
num--;
}while(num > 0);
Résultat d'exécution
do-while_num => 0
Dans l'instruction do-while, le processus n'est exécuté qu'une seule fois et l'instruction do-while se termine car l'expression conditionnelle est fausse.
Notez qu'il existe de telles différences.
S'il n'y a qu'une seule instruction pour traiter à la fois les instructions while et do-while, il est possible d'omettre {}.
Dans le cas de while
int num = 0;
while (num < 5) System.out.println("num => " + num++);
Résultat d'exécution
while_num => 0
while_num => 1
while_num => 2
while_num => 3
while_num => 4
do-Dans le cas de while
int num = 5;
do
System.out.println("do-while_num => " + num--);
while(num > 0);
Résultat d'exécution
do-while_num => 5
do-while_num => 4
do-while_num => 3
do-while_num => 2
do-while_num => 1
L'instruction for répète également le processus pendant que le jugement de condition est vrai.
Dans l'instruction while et do-while, seule l'expression conditionnelle était décrite dans (),
Dans le () de l'instruction for, ** déclarez la variable count, initialisez **, ** expression conditionnelle ** et ** mettez à jour la variable count **.
syntaxe
for(Équation 1;Équation 2;Équation 3;) {
Déclaration de processus;
}
Le déroulement de l'instruction for est le suivant.
-Déclarer et initialiser une variable (variable de compteur) qui indique le nombre de répétitions dans l'équation 1. ・ La condition est jugée par l'équation 2. -Si le jugement de condition est vrai, l'instruction de traitement est exécutée. -Une fois le processus exécuté, la variable de compteur est mise à jour par l'équation 3. ・ La condition est à nouveau jugée par l'équation 2. -Si le jugement de l'équation 2 est faux, l'instruction for est terminée.
Voyons en fait le code et le résultat de l'exécution.
exemple de déclaration for
for(int i = 0; i < 5; i++) {
System.out.println("i => " + i);
}
Résultat d'exécution
i => 0
i => 1
i => 2
i => 3
i => 4
De cette manière, l'instruction for peut également décrire le même traitement que l'instruction while et l'instruction do-while.
L'instruction for est également exécutée par la méthode de description suivante.
Méthode de description omise de l'instruction for_Exemple 1
int num = 0;
for(; num < 5; num++) {
System.out.println("num => " + num);
}
Résultat d'exécution
num => 0
num => 1
num => 2
num => 3
num => 4
Au lieu de déclarer et d'initialiser les variables de compteur avec l'instruction for, cela se fait à l'avance. Cela fonctionne également avec cette méthode de description.
Méthode de description omise de l'instruction for_Exemple 2
for(int num = 0; num < 5; ) {
System.out.println("num => " + num++);
}
Résultat d'exécution
num => 0
num => 1
num => 2
num => 3
num => 4
La variable num est incrémentée et mise à jour dans l'instruction de traitement. Cela fonctionne également avec cette méthode de description.
Notez que si vous oubliez d'incrémenter, vous vous retrouverez avec une ** boucle infinie **.
Il y a quelques règles sur la façon d'écrire dans () de l'instruction for, alors voyons.
Ce qui suit entraînera une erreur car seules les variables sont décrites dans l'équation 1.
Erreur de compilation
int num = 1;
for(num; num < 5; num++) {
System.out.println("num => " + num);
}
L'équation 1 doit être une déclaration comme suit:
Plan d'amélioration
int num = 1;
for(num += 1; num < 5; num++) {
System.out.println("num => " + num);
}
Résultat d'exécution
num => 2
num => 3
num => 4
Ce qui suit entraînera une erreur car l'expression de déclaration multiple est décrite dans Expression 1.
Erreur de compilation
for(int i = 0, int = j = 0; i < 5; i++) {
System.out.println("i => " + i);
System.out.println("j => " + (j+=2));
System.out.println("===============");
}
Il ne doit y avoir qu'une seule expression déclarative dans l'équation 1, comme indiqué ci-dessous.
Plan d'amélioration
for(int i = 0, j = 0; i < 5; i++) {
System.out.println("i => " + i);
System.out.println("j => " + (j+=2));
System.out.println("===============");
}
Résultat d'exécution
i => 0
j => 2
===============
i => 1
j => 4
===============
i => 2
j => 6
===============
i => 3
j => 8
===============
i => 4
j => 10
===============
En séparant les expressions par des virgules, vous pouvez entrer plusieurs processus de mise à jour des variables de compteur. Réécrivons le code ci-dessus.
Exemple de mise en multiple de l'équation 3
for(int i = 0, j = 2; i < 5; i++, j+=2) {
System.out.println("i => " + i);
System.out.println("j => " + j);
System.out.println("===============");
}
Résultat d'exécution
i => 0
j => 2
===============
i => 1
j => 4
===============
i => 2
j => 6
===============
i => 3
j => 8
===============
i => 4
j => 10
===============
Vous pouvez afficher le même résultat.
En tant que méthode de description plus pratique pour l'instruction for, elle est utilisée lorsque tous les éléments d'un tableau ou d'une collection sont sortis dans l'ordre et traités.
syntaxe
for(Déclaration de variable:Nom de la variable de référence) {
Déclaration de processus;
}
Voyons en fait le code et le résultat de l'exécution.
Exemple d'instruction Extended for
int[] numbers = {1, 2, 3, 4, 5};
for(int val : numbers) {
System.out.println(val);
}
Résultat d'exécution
val => 1
val => 2
val => 3
val => 4
val => 5
Le flux d'affectation des éléments de «nombres à la variable val un par un et de sortie» est répété.
Décrivons le même processus avec une instruction for et comparons.
Pour déclaration
int[] numbers = {1, 2, 3, 4, 5};
for(int i = 0; i < numbers.length; i++) {
System.out.println("numbers[" + i + "] => " + numbers[i]);
}
Résultat d'exécution
numbers[0] => 1
numbers[1] => 2
numbers[2] => 3
numbers[3] => 4
numbers[4] => 5
En décrivant avec l'instruction for étendue, il n'est pas nécessaire de déclarer la variable de compteur, d'initialiser ou d'expression conditionnelle et de décrire le processus de mise à jour de la variable de compteur. Il peut être décrit plus simplement que l'instruction for.
Le type de déclaration de variable doit correspondre au type de la variable référencée. Ce qui suit entraînera une erreur.
Erreur de compilation
String[] names = {"Tanaka", "Sato", "Suzuki"};
for(int val : names) {
System.out.println("name => " + val);
}
Cela est dû au fait que la variable de référence est un tableau de type String, alors que la déclaration de variable est de type «int».
Veillez à faire correspondre les types de la variable de référence et la variable qui reçoit chaque élément.
Plan d'amélioration
String[] names = {"Tanaka", "Sato", "Suzuki"};
for(String val : names) {
System.out.println("name => " + val);
}
Résultat d'exécution
name =>Tanaka
name =>Sato
name =>Suzuki
** S'il n'y a qu'une seule instruction à traiter à la fois pour instruction et étendue pour instruction, il est possible d'omettre {}. ** **
Pour déclaration
for(int i = 0; i < 3; i++)
System.out.println("i => " + i);
Résultat d'exécution
i => 0
i => 1
i => 2
Pour prolongé pour déclaration
int[] numbers = {10, 20, 30};
for(int val : numbers)
System.out.println("val => " + val);
Résultat d'exécution
val => 10
val => 20
val => 30
** L'inférence de type de variable locale (var) est disponible. ** ** (Je vais résumer l'inférence de type de variable locale dans un autre article.)
Pour déclaration
for(var i = 0; i < 3; i++) {
//réduction
}
Pour prolongé pour déclaration
for(var val : numbers) {
//réduction
}
Le processus itératif ci-dessus était que ** l'expression conditionnelle continuerait à être exécutée tant qu'elle était vraie **.
Si vous souhaitez quitter le processus itératif sous certaines conditions, utilisez les instructions de contrôle itératives ** instruction break ** et ** instruction continue **.
Il est utilisé pour sortir de la boucle infinie des instructions répétées lors de l'interruption du traitement répétitif en cours d'exécution. Il est également utilisé dans le cas de l'instruction switch.
Après avoir quitté la boucle, procédez comme suit:
Exemple d'instruction Break
for(int i = 0; ; i++) {
if(i == 5) {
break;
}
System.out.println("i => " + i);
}
System.out.println("Traitement après l'instruction for");
Résultat d'exécution
i => 0
i => 1
i => 2
i => 3
i => 4
Traitement après l'instruction for
Il n'y a pas d'expression conditionnelle car j'ai oublié d'écrire l'expression 2. Par conséquent, cela devient une boucle infinie.
Cependant, comme il y a un break; dans le bloc de ʻif (i == 5) `, il rompra la boucle lorsque ** i devient 5. ** **
Et le traitement après l'exécution de l'instruction for.
Il est utilisé lorsque le traitement répétitif en cours d'exécution n'est pas interrompu, mais seulement lorsque le traitement est ignoré, l'expression conditionnelle est jugée et le traitement répétitif est poursuivi.
Exemple d'instruction continue
for(int i = 0; i < 10; i++) {
if((i % 3) == 0) {
continue;
}
System.out.println("i => " + i);
}
System.out.println("Traitement après l'instruction for");
Résultat d'exécution
i => 1
i => 2
i => 4
i => 5
i => 7
i => 8
Traitement après l'instruction for
En ayant continue; dans le bloc de ʻif ((i% 3) == 0) `,
** i est divisé par 3 et le traitement est ignoré lorsque le reste est égal à 0. (La boucle continue tant que le jugement de condition dans l'équation 2 est vrai) **
Ensuite, après la fin de l'instruction for, le traitement suivant est exécuté.
Si l'instruction de répétition est imbriquée (s'il y en a plusieurs), l'instruction break et l'instruction continue décrites dans l'instruction de répétition interne sont appliquées uniquement au processus de répétition interne. Si vous souhaitez sortir de la boucle externe ou l'ignorer, vous pouvez utiliser le ** label **.
syntaxe
Nom de l'étiquette:
for(Équation 1;Équation 2;Équation 3;) {
for(Équation 1;Équation 2;Équation 3;) {
casser ou continuer le nom de l'étiquette;
}
}
Voyons comment le processus diffère selon que l'instruction break et l'instruction continue ont des étiquettes.
Si vous n'utilisez pas l'étiquette, ce sera comme suit. Je veux terminer la boucle lorsque i et j valent 1. Il est mis en œuvre sur l'hypothèse que.
Pas de label
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
System.out.println("i: " + i + ", j: " + j);
if(i == 1 && j == 1) {
break;
}
}
}
Résultat d'exécution
i: 0, j: 0
i: 0, j: 1
i: 0, j: 2
i: 1, j: 0
i: 1, j: 1
i: 2, j: 0
i: 2, j: 1
i: 2, j: 2
La boucle ne se termine pas, i est incrémenté à la boucle suivante.
Lors de l'utilisation d'une étiquette, ce sera comme suit.
Avec étiquette
loop:
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
System.out.println("i: " + i + ", j: " + j);
if(i == 1 && j == 1) {
break loop;
}
}
}
Résultat d'exécution
i: 0, j: 0
i: 0, j: 1
i: 0, j: 2
i: 1, j: 0
i: 1, j: 1
Lorsque i et j valent 1, la boucle externe peut également être sortie.
Si vous n'utilisez pas l'étiquette, ce sera comme suit. Lorsque i et j valent 1, je veux passer à la boucle suivante qui incrémente i. Il est mis en œuvre sur l'hypothèse que.
Pas de label
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
if(i == 1 && j == 1) {
continue;
}
System.out.println("i: " + i + ", j: " + j);
}
}
Résultat d'exécution
i: 0, j: 0
i: 0, j: 1
i: 0, j: 2
i: 1, j: 0
i: 1, j: 2
i: 2, j: 0
i: 2, j: 1
i: 2, j: 2
Il est ignoré uniquement lorsque i et j valent 1.
Lors de l'utilisation d'une étiquette, ce sera comme suit.
Avec étiquette
loop2:
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
if(i == 1 && j == 1) {
continue loop2;
}
System.out.println("i: " + i + ", j: " + j);
}
}
Résultat d'exécution
i: 0, j: 0
i: 0, j: 1
i: 0, j: 2
i: 1, j: 0
i: 2, j: 0
i: 2, j: 1
i: 2, j: 2
Lorsque i et j valent 1, vous pouvez passer à la boucle suivante qui incrémente i.
En utilisant labels de cette manière, il est possible de sortir de plusieurs boucles ou de les ignorer
J'ai appris la syntaxe pour répéter le même processus et l'instruction de contrôle itérative pour interrompre ou sauter le processus selon les conditions. En les utilisant correctement, vous pouvez écrire le code clairement, et vous n'avez pas à écrire le même processus plusieurs fois, donc je veux le maîtriser.
** [Introduction à Java] Maîtrisons le traitement itératif! (pour et pendant) ** ** Extended for statement (for-each statement) **
Recommended Posts