Qu’est-ce que le mot-clé «continue» et comment fonctionne-t-il en Java?

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.

  • Quel est le mot-clé continue ?
  • Comment ça marche?
  • Quand est-il utilisé?

    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 !!