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 pourrait m'expliquer ce qu'il fait.

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

Une continueinstruction sans étiquette sera réexécutée à partir de la condition la plus interne whileou la doboucle, et à partir de l'expression de mise à jour de la forboucle la plus interne . Il est souvent utilisé pour interrompre précocement le traitement d'une boucle et éviter ainsi les ifinstructions profondément imbriquées . Dans l'exemple continuesuivant, 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, continuesera 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, continueest é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 continuepour simuler une forme limitée de goto. Dans l'exemple suivant, le continueva réexécuter la for (;;)boucle vide .

aLoopName: for (;;) {
  // ...
  while (someCondition)
  // ...
    if (otherCondition)
      continue aLoopName;

continueest 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.

Voyons un exemple:

int sum = 0;
for(int i = 1; i <= 100 ; i++){
    if(i % 2 == 0)
         continue;
    sum += i;
}

Cela obtiendrait la somme des seuls nombres impairs de 1 à 100.

Si vous considérez le corps d'une boucle comme un sous-programme, continuec'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 whileou forn'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, continuepasse à la prochaine itération de la boucle, tout en breaksortant 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/ breaket 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/ breakfailing.

À 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, breakEt 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é continuesautera 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 - whilevous ê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 aSetles 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".

Je suis un peu en retard à la fête, mais ...

Il convient de mentionner que cela continueest 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 bufferse fait dans l'expression contrôlant la whileboucle. 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 (...)
    ;

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]