J’ai vu ce mot-clé pour la première fois et je me demandais si quelqu’un pouvait m’expliquer ce qu’il faisait.
continue
? Une instruction continue
sans étiquette réexécutera à partir de la condition la boucle while
ou do
la plus interne et à partir de l’expression update de la boucle la plus interne. Il est souvent utilisé pour mettre fin rapidement au traitement d’une boucle et éviter ainsi les instructions if
nestedes. Dans l’exemple suivant, continue
va recevoir la ligne suivante, sans traiter l’instruction suivante dans la boucle.
while (getNext(line)) { if (line.isEmpty() || line.isComment()) continue; // More code here }
Avec une étiquette, continue
ré-exécuter 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 nestedes, ou simplement pour plus de clarté.
Parfois, continue
est également utilisé comme un espace réservé afin de rendre un corps de boucle vide plus clair.
for (count = 0; foo.moreData(); count++) continue;
La même déclaration sans étiquette existe également en C et C ++. L’équivalent en Perl est le next
.
Ce type de stream de contrôle n’est pas recommandé, mais si vous le souhaitez, vous pouvez également continue
à simuler une forme limitée de goto
. Dans l’exemple suivant, le continue
ré-exécute la boucle vide for (;;)
.
aLoopName: for (;;) { // ... while (someCondition) // ... if (otherCondition) continue aLoopName;
continue
est un peu comme goto
. Êtes-vous familier avec la break
? Il est plus facile de penser à eux en contraste:
break
met fin à la boucle (saute au code en dessous).
continue
termine le rest du traitement du code dans la boucle pour l’itération en cours, mais continue la boucle.
Voyons un exemple:
int sum = 0; for(int i = 1; i <= 100 ; i++){ if(i % 2 == 0) continue; sum += i; }
Cela donnerait la sum des seuls nombres impairs de 1 à 100.
Si vous considérez le corps d’une boucle comme un sous-programme, continue
est en quelque sorte un return
. Le même mot-clé existe en C et sert le même objective. Voici un exemple:
for(int i=0; i < 10; ++i) { if (i % 2 == 0) { continue; } System.out.println(i); }
Cela imprimera uniquement les nombres impairs.
En général, je vois continue
(et break
) comme un avertissement que le code pourrait utiliser un refactoring, en particulier si la déclaration while ou for
loop n’est pas immédiatement visible. La même chose est vraie pour le return
au milieu d’une méthode, mais pour une raison légèrement différente.
Comme d’autres l’ont déjà dit, continue
jusqu’à l’itération suivante de la boucle, tandis que le break
sort de la boucle englobante.
Il peut s’agir de bombes à retardement de maintenance car il n’existe pas de lien immédiat entre la continue
/ break
et la boucle qu’elle poursuit / interrompt autre que le contexte; Ajouter une boucle interne ou déplacer les “entrailles” de la boucle dans une méthode distincte et vous avez un effet caché de l’échec continue
/ break
.
À mon humble avis, il est préférable de les utiliser comme mesure de dernier recours, puis de s’assurer que leur utilisation est regroupée étroitement au début ou à la fin de la boucle afin que le développeur suivant puisse voir les limites de la boucle dans un écran .
continue
, break
et return
(autre que le One True Return à la fin de votre méthode), tous tombent dans la catégorie générale des «GOTOs cachés». Ils placent le contrôle des boucles et des fonctions dans des endroits inattendus, ce qui provoque éventuellement des bogues.
Comme déjà mentionné, continue
ignorer le code en dessous et jusqu’à la fin de la boucle. Ensuite, vous êtes déplacé à la condition de la boucle et exécutez l’itération suivante si cette condition est toujours valide (ou s’il existe un indicateur, à la condition de la boucle indiquée).
Il faut souligner que dans le cas de do - while
vous êtes déplacé vers la condition au bas de la liste après une continue
, 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 aSet= new HashSet (); 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
contiendra des nombres impairs seulement 100% … vous avez tort!
“continue” en Java signifie aller à la fin de la boucle en cours, signifie: si le compilateur voit continuer dans une boucle, il ira à la prochaine itération
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 se déplacer dans la prochaine itération
for (int i = 0; i < 10; i++) { if (i%2 == 0) continue; System.out.println(i+""); }
Considérez une condition If Else. Une instruction continue exécute ce qu’il y a dans une condition et sort de la condition, c’est-à-dire qu’elle saute à l’itération ou à la condition suivante. Mais une pause quitte la boucle. Considérons le programme suivant. ‘
public class ContinueBreak { public static void main(Ssortingng[] args) { Ssortingng[] table={"aa","bb","cc","dd"}; for(Ssortingng ss:table){ if("bb".equals(ss)){ continue; } System.out.println(ss); if("cc".equals(ss)){ break; } } System.out.println("Out of the loop."); } }
Il va imprimer: aa cc Hors de la boucle.
Si vous utilisez break au lieu de continue (After if.), Il suffira d’ imprimer aa et hors de la boucle .
Si la condition “bb” est égale à ss est satisfaite: For Continue: passe à la prochaine itération, par exemple “cc” .equals (ss). For Break: Il sort de la boucle et imprime “Out of the loop”.
Je suis un peu en retard à la fête, mais …
Il convient de mentionner que 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 d’un caractère et de son ajout à la buffer
se fait dans l’expression contrôlant la boucle while. La déclaration continue
sert d’indicateur visuel du fait que la boucle n’a pas besoin d’un corps.
C’est un peu plus évident que l’équivalent:
while (...) { }
et certainement mieux (et plus sûr) style de codage que d’utiliser un énoncé vide comme:
while (...) ;
Fondamentalement, en java, continuez est une déclaration. Donc l’instruction continue est normalement utilisée avec les boucles pour ignorer l’itération en cours.
Pour savoir comment et quand il est utilisé dans Java, reportez-vous au lien ci-dessous. Il a des explications avec exemple.
http://www.flowerbrackets.com/continue-java-example/
J’espère que cela aide !!