L'instruction continue en Java

continue est le cousin plus léger de break. Là où break dit arrête complètement la boucle, continue dit saute le reste de cette itération et passe à la suivante. La boucle continue de s'exécuter.

Cette page explique comment continue reprend l'exécution pour chaque type de boucle, le piège de la boucle infinie dans les boucles while, son utilisation pour filtrer des éléments, quand le préférer à un if inversé, et comment il n'affecte que la boucle la plus interne.

Utilisation de base

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

Résultat :

0
1
3
4

Quand i == 2, continue saute directement à l'étape de mise à jour de la boucle (i++), en ignorant le println. La boucle vérifie ensuite sa condition et continue avec i == 3.

Comment les boucles reprennent

Le comportement dépend du type de boucle :

• for — exécute l'expression de mise à jour, puis vérifie la condition
• while — vérifie la condition immédiatement
• do/while — vérifie la condition immédiatement (en bas de la boucle)
• for amélioré — passe à l'élément suivant

Un continue dans un while qui oublie de faire avancer l'état peut rapidement devenir une boucle infinie :

int i = 0;
while (i < 5) {
  if (i == 2) {
    continue;     // i never advances — infinite loop!
  }
  System.out.println(i);
  i++;
}

C'est une erreur classique. Soit vous incrémentez avant le continue, soit vous utilisez une boucle for afin que l'étape de mise à jour s'exécute automatiquement.

Filtrage d'éléments

L'utilisation la plus courante de continue est « ignorer les éléments qui ne m'intéressent pas » :

int[] nums = {3, 7, 2, 8, 5, 4};

for (int n : nums) {
  if (n % 2 != 0) {
    continue;          // skip odd numbers
  }
  System.out.println(n);
}

Résultat : 2 8 4.

continue vs. inversion de la condition

Il est souvent possible de réécrire un continue sous forme d'un if qui enveloppe le reste du corps :

for (int n : nums) {
  if (n % 2 == 0) {
    System.out.println(n);
  }
}

Fonctionnellement identique. Le choix est une question de style :

• Utilisez continue quand il y a plusieurs conditions de saut ; une série de gardes de sortie anticipée est plus plate que des if profondément imbriqués.
• Utilisez un if englobant quand la condition de saut est simple et le corps est court.

// continue style — easy to add another skip condition
for (User u : users) {
  if (u == null) continue;
  if (!u.isActive()) continue;
  if (u.isBanned()) continue;
  process(u);
}

continue ne saute qu'un seul niveau

Comme break, continue n'affecte que la boucle interne la plus proche :

for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++) {
    if (j == 1) continue;     // only skips inner iteration
    System.out.println(i + "," + j);
  }
}

Résultat :

0,0
0,2
1,0
1,2
2,0
2,2

Pour effectuer un continue sur la boucle externe depuis l'intérieur de la boucle interne, utilisez un continue étiqueté — traité dans les instructions étiquetées.

Un exemple concret

Prochaine étape

Lorsque vous combinez des boucles for, vous obtenez des boucles imbriquées — la base pour travailler avec des grilles, des tableaux et des tableaux à 2 dimensions.

Entraînement