J'ai vu ce mot-clé pour la première fois et je me demandais si quelqu'un pourrait m'expliquer ce qu'il fait.
- Quel est le
continue
mot clé? - Comment ça marche?
- Quand est-il utilisé?
J'ai vu ce mot-clé pour la première fois et je me demandais si quelqu'un pourrait m'expliquer ce qu'il fait.
continue
mot clé?Réponses:
Une continue
instruction sans étiquette sera réexécutée à partir de la condition la plus interne while
ou la do
boucle, et à partir de l'expression de mise à jour de la for
boucle la plus interne . Il est souvent utilisé pour interrompre précocement le traitement d'une boucle et éviter ainsi les if
instructions profondément imbriquées . Dans l'exemple continue
suivant, la ligne suivante sera obtenue, sans traiter l'instruction suivante dans la boucle.
while (getNext(line)) {
if (line.isEmpty() || line.isComment())
continue;
// More code here
}
Avec une étiquette, continue
sera réexécutée à partir de la boucle avec l'étiquette correspondante, plutôt que la boucle la plus interne. Cela peut être utilisé pour échapper à des boucles profondément imbriquées, ou simplement pour plus de clarté.
Parfois, continue
est également utilisé comme espace réservé afin de rendre plus clair un corps de boucle vide.
for (count = 0; foo.moreData(); count++)
continue;
La même instruction sans étiquette existe également en C et C ++. L'équivalent en Perl est next
.
Ce type de flux de contrôle n'est pas recommandé, mais si vous le souhaitez, vous pouvez également l'utiliser continue
pour simuler une forme limitée de goto
. Dans l'exemple suivant, le continue
va réexécuter la for (;;)
boucle vide .
aLoopName: for (;;) {
// ...
while (someCondition)
// ...
if (otherCondition)
continue aLoopName;
continue
est un peu comme goto
. Connaissez-vous break
? Il est plus facile de penser à eux en revanche:
break
termine la boucle (passe au code en dessous).
continue
termine le reste du traitement du code dans la boucle pour l'itération en cours, mais continue la boucle.
Si vous considérez le corps d'une boucle comme un sous-programme, continue
c'est un peu comme return
. Le même mot-clé existe en C et sert le même but. Voici un exemple artificiel:
for(int i=0; i < 10; ++i) {
if (i % 2 == 0) {
continue;
}
System.out.println(i);
}
Cela n'imprimera que les nombres impairs.
En général, je vois continue
(et break
) comme un avertissement que le code pourrait utiliser une refactorisation, surtout si la déclaration de boucle while
ou for
n'est pas immédiatement en vue. Il en va de même pourreturn
le milieu d'une méthode, mais pour une raison légèrement différente.
Comme d'autres l'ont déjà dit, continue
passe à la prochaine itération de la boucle, tout en break
sortant de la boucle englobante.
Il peut s'agir de bombes à retardement de maintenance car il n'y a pas de lien immédiat entre le continue
/ break
et la boucle qu'il continue / rompt autre que le contexte; ajoutez une boucle interne ou déplacez les "entrailles" de la boucle dans une méthode distincte et vous aurez un effet caché de continue
/ break
failing.
À mon humble avis, il est préférable de les utiliser comme mesure de dernier recours, puis de s'assurer que leur utilisation est étroitement groupée au début ou à la fin de la boucle afin que le développeur suivant puisse voir les «limites» de la boucle sur un seul écran .
continue
, break
Et return
(autre que le seul vrai retour à la fin de votre méthode) entrent tous dans la catégorie générale des « GOTO cachés ». Ils placent le contrôle des boucles et des fonctions dans des endroits inattendus, ce qui finit par provoquer des bugs.
"continuer" en Java signifie aller à la fin de la boucle en cours, signifie: si le compilateur voit continuer dans une boucle, il ira à l'itération suivante
Exemple: Ceci est un code pour imprimer les nombres impairs de 1 à 10
le compilateur ignorera le code d'impression chaque fois qu'il verra continuer à passer à la prochaine itération
for (int i = 0; i < 10; i++) {
if (i%2 == 0) continue;
System.out.println(i+"");
}
Comme déjà mentionné continue
sautera le traitement du code en dessous et jusqu'à la fin de la boucle. Ensuite, vous passez à l' état de la boucle et exécutez l'itération suivante si cette condition est toujours valable (ou s'il y a un indicateur, vers la condition de la boucle indiquée).
Il faut souligner que dans le cas où do - while
vous êtes déplacé vers la condition en bas après uncontinue
, pas au début de la boucle.
C'est pourquoi beaucoup de gens ne répondent pas correctement à ce que le code suivant va générer.
Random r = new Random();
Set<Integer> aSet= new HashSet<Integer>();
int anInt;
do {
anInt = r.nextInt(10);
if (anInt % 2 == 0)
continue;
System.out.println(anInt);
} while (aSet.add(anInt));
System.out.println(aSet);
* Si votre réponse est que aSet
les nombres impairs ne contiendront que 100% ... vous vous trompez!
Continuer est un mot - clé en Java et il est utilisé pour ignorer l'itération actuelle.
Supposons que vous souhaitiez imprimer tous les nombres impairs de 1 à 100
public class Main {
public static void main(String args[]) {
//Program to print all odd numbers from 1 to 100
for(int i=1 ; i<=100 ; i++) {
if(i % 2 == 0) {
continue;
}
System.out.println(i);
}
}
}
L' instruction continue dans le programme ci-dessus saute simplement l'itération lorsque i est pair et imprime la valeur de i lorsqu'elle est impaire.
L' instruction Continue vous fait simplement sortir de la boucle sans exécuter les instructions restantes à l'intérieur de la boucle et déclenche l'itération suivante.
Considérez une condition If Else. Une instruction continue exécute ce qui se trouve dans une condition et sort de la condition, c'est-à-dire passe à l'itération ou à la condition suivante. Mais une pause quitte la boucle. Considérez le programme suivant. "
public class ContinueBreak {
public static void main(String[] args) {
String[] table={"aa","bb","cc","dd"};
for(String ss:table){
if("bb".equals(ss)){
continue;
}
System.out.println(ss);
if("cc".equals(ss)){
break;
}
}
System.out.println("Out of the loop.");
}
}
Il imprimera: aa cc Hors de la boucle.
Si vous utilisez break à la place de continue (After if.), Il imprimera simplement aa et sortira de la boucle .
Si la condition "bb" est égale à ss est satisfaite: For Continue: passe à l'itération suivante, c'est-à-dire "cc" .equals (ss). Pour Break: il sort de la boucle et affiche "Out of the loop".
break
Je suis un peu en retard à la fête, mais ...
Il convient de mentionner que cela continue
est utile pour les boucles vides où tout le travail est effectué dans l'expression conditionnelle contrôlant la boucle. Par exemple:
while ((buffer[i++] = readChar()) >= 0)
continue;
Dans ce cas, tout le travail de lecture et d'ajout d'un caractère buffer
se fait dans l'expression contrôlant la while
boucle. lecontinue
énoncé sert d'indicateur visuel que la boucle n'a pas besoin de corps.
C'est un peu plus évident que l'équivalent:
while (...)
{ }
et un style de codage certainement meilleur (et plus sûr) que d'utiliser une instruction vide comme:
while (...)
;
while
devenir le corps de la while
clause, et ce ne serait pas visuellement évident. Une explicite continue
est évidente et transmet une intention qu'une déclaration vide ne fait pas.
Fondamentalement, en java, continue est une déclaration. Donc, l'instruction continue est normalement utilisée avec les boucles pour ignorer l'itération actuelle.
Pour savoir comment et quand il est utilisé en Java, reportez-vous au lien ci-dessous. Il a une explication avec un exemple.
https://www.flowerbrackets.com/continue-java-example/
J'espère que ça aide !!
continue
doit être à l'intérieur d'une boucle Sinon cela montre l'erreur ci-dessous:
Continuez en dehors de la boucle
L'instruction continue est utilisée dans la structure de contrôle de boucle lorsque vous devez passer immédiatement à l'itération suivante de la boucle.
Il peut être utilisé avec une boucle for ou une boucle while. L'instruction Java continue est utilisée pour continuer la boucle. Il continue le flux actuel du programme et ignore le code restant à la condition spécifiée.
Dans le cas d'une boucle interne, elle continue uniquement la boucle interne.
Nous pouvons utiliser l'instruction Java continue dans tous les types de boucles telles que la boucle for, la boucle while et la boucle do-while.
par exemple
class Example{
public static void main(String args[]){
System.out.println("Start");
for(int i=0; i<10; i++){
if(i==5){continue;}
System.out.println("i : "+i);
}
System.out.println("End.");
}
}
production:
Start
i : 0
i : 1
i : 2
i : 3
i : 4
i : 6
i : 7
i : 8
i : 9
End.
[le numéro 5 est sauter]