web-dev-qa-db-fra.com

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 mot clé continue?
  • Comment ça marche?
  • Quand est-il utilisé?
javakeywordcontinue
294
faceless1_14

Une instruction continue sans étiquette sera ré-exécutée à partir de la condition la boucle while ou do la plus interne, et de l'expression de mise à jour de la boucle for la plus interne. Il est souvent utilisé pour terminer prématurément le traitement d'une boucle et éviter ainsi les instructions if imbriquées. Dans l'exemple suivant, continue obtiendra 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 sera ré-exécuté à partir de la boucle avec l'étiquette correspondante, plutôt que la boucle la plus à l'intérieur. Cela peut être utilisé pour échapper à des boucles profondément imbriquées, ou simplement pour plus de clarté.

Parfois, continue est également utilisé comme paramètre fictif afin de rendre plus clair le corps d'une 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 utiliser continue pour simuler une forme limitée de goto. Dans l'exemple suivant, la continue ré-exécutera la boucle vide for (;;).

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

continue est un peu comme goto. Connaissez-vous break? Il est plus facile de penser à eux en contraste:

  • break termine la boucle (passe au code situé en dessous).

  • continue termine le reste du traitement du code dans la boucle pour l'itération en cours, mais poursuit la boucle.

501
Dustin

Voyons un exemple:

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

Cela donnerait la somme des nombres impairs de 1 à 100.

98
Gant

Si vous considérez le corps d'une boucle comme un sous-programme, continue est un peu comme return. Le même mot-clé existe en C et a le même objectif. Voici un exemple artificiel:

for(int i=0; i < 10; ++i) {
  if (i % 2 == 0) {
    continue;
  }
  System.out.println(i);
}

Cela imprimera uniquement les nombres impairs.

28
Vineet

Généralement, je vois continue (et break) comme un avertissement indiquant que le code pourrait utiliser un refactoring, en particulier si la boucle while ou for la déclaration n'est pas immédiatement visible. Il en va de même pour 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 passe à la prochaine itération de la boucle, tandis que break sort de la boucle qui l'entoure.

Il peut s’agir de bombe à retardement de maintenance car il n’ya pas de lien immédiat entre la continue/break et la boucle qu’elle continue/casse autre que le contexte; ajoutez une boucle interne ou déplacez les "entrailles" de la boucle dans une méthode distincte et vous obtenez un effet caché de l'échec de continue/break.

IMHO, il est préférable de les utiliser en dernier recours, puis de s'assurer que leur utilisation est bien regroupé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 One True Return à la fin de votre méthode) entrent tous dans la catégorie générale des "GOTO cachés". Ils placent le contrôle de boucle et de fonction dans des endroits inattendus, ce qui finit par provoquer des bugs.

17
Tom Dibble

"continuer" dans Java signifie aller à la fin de la boucle en cours, signifie: si le compilateur voit continuer dans une boucle, il passera à 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 continuer son passage à la prochaine itération

for (int i = 0; i < 10; i++) { 
    if (i%2 == 0) continue;    
    System.out.println(i+"");
}
5
Ibrahim Hout

Comme déjà mentionné, continue ignorera le traitement du code situé en dessous et jusqu'à la fin de la boucle. Ensuite, vous êtes déplacé vers le condition de la boucle et exécutez l'itération suivante si cette condition est toujours valide (ou, s'il existe un indicateur, vers la condition de la boucle indiquée).

Il faut souligner que, dans le cas de do - while, vous êtes déplacé vers la condition située au bas de la page après un continue, et non 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 ne contiendra que des nombres impairs 100% ... vous vous trompez!

4
Kostas Chalkias

Considérons une condition If Else. Une instruction continue exécute ce qui est dans une condition et sort de la condition, c’est-à-dire saute à la prochaine itération ou condition. Mais une pause laisse 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 (après if.), Il ne fera que imprimer aa et sortir de la boucle.

Si la condition "bb" égale ss est satisfaite: pour continuer: passe à l'itération suivante, c'est-à-dire "cc" .equals (ss). Pour Break: Il sort de la boucle et affiche "Out of the loop".

3
phanindravarma

Continuer est un mot clé dans Java & est utilisé pour ignorer l'itération en cours.

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'énoncé continue du programme ci-dessus ignore simplement l'itération lorsque i est pair et affiche la valeur de i quand il est impair.

Suite L'instruction vous sort simplement de la boucle sans exécuter les instructions restantes à l'intérieur de la boucle et déclenche l'itération suivante.

2
Akshay

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

Il est utile 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 à buffer est effectué dans l'expression contrôlant la boucle while. L'instruction continue sert d'indicateur visuel indiquant que la boucle n'a pas besoin de corps.

C'est un peu plus évident que l'équivalent:

while (...)
{ }

et un style de codage nettement meilleur (et plus sûr) que d'utiliser une instruction vide telle que:

while (...)
    ;
2
David R Tribble

Fondamentalement, en Java, continue 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é en Java, reportez-vous au lien ci-dessous. Il a une explication avec exemple.

https://www.flowerbrackets.com/continue-Java-example/

J'espère que ça aide !!

1
Shiva