L'istruzione break in Java

break è l'uscita di emergenza. Interrompe immediatamente il ciclo più interno o il blocco switch in cui si trova, e l'esecuzione continua con ciò che segue. Usalo quando il lavoro del ciclo è terminato e non c'è motivo di continuare a iterare.

Uscire da un ciclo

for (int i = 0; i < 100; i++) {
  if (i == 5) {
    break;
  }
  System.out.println(i);
}
// continues here

Stampa 0 1 2 3 4 e termina. La condizione del ciclo (i < 100) e l'aggiornamento (i++) vengono abbandonati nel momento in cui break viene eseguito.

Un utilizzo tipico: cercare un elemento e fermarsi non appena lo si trova:

int[] nums = {3, 7, 2, 8, 5};
int target = 8;
int foundAt = -1;

for (int i = 0; i < nums.length; i++) {
  if (nums[i] == target) {
    foundAt = i;
    break;
  }
}
System.out.println("found at index: " + foundAt);

Senza break, si continuerebbero a controllare elementi che si sa già non essere la risposta.

break in un while

Funziona in modo identico in while e do/while:

int n = 1;
while (true) {
  if (n > 1000) {
    break;
  }
  n *= 2;
}
System.out.println(n);   // 1024

while (true) { ... break; } è il pattern standard per "esegui il ciclo finché una condizione decisa all'interno del corpo non viene soddisfatta."

break in uno switch

In un'istruzione switch tradizionale, break esce dallo switch — impedendo la caduta nel caso successivo. Lo abbiamo visto nel capitolo sullo switch:

switch (cmd) {
  case "start": startServer(); break;
  case "stop":  stopServer();  break;
  default:      help();        break;
}

Le espressioni switch in forma freccia trattate nelle espressioni switch non hanno caduta, quindi non necessitano di break.

for (String cmd : commands) {
  switch (cmd) {
    case "quit":
      break;          // exits the switch, NOT the for loop — the loop keeps going
    default:
      process(cmd);
  }
}

Per uscire dal ciclo dall'interno dello switch, è necessario un break con etichetta (mostrato di seguito) oppure un flag che il ciclo controlla in seguito.

break esce solo da un livello

break esce dal ciclo o dallo switch più interno. Nei cicli annidati, lascia solo quello interno:

for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++) {
    if (j == 1) break;     // only exits the inner loop
    System.out.println(i + "," + j);
  }
}

Output:

0,0
1,0
2,0

Per uscire da tutti i cicli annidati in una volta sola, usa un break con etichetta — trattato nelle istruzioni con etichetta:

outer:
for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++) {
    if (i == 1 && j == 1) break outer;
    System.out.println(i + "," + j);
  }
}

break vs return

Se il lavoro che segue il ciclo è significativo, usa break. Se il metodo non ha altro da fare una volta terminato il ciclo, usa direttamente return:

for (int i = 0; i < nums.length; i++) {
  if (nums[i] == target) {
    return i;       // shorter than break + return after the loop
  }
}
return -1;

Entrambi sono corretti. return è spesso la scelta più pulita per i metodi di tipo ricerca.

Un esempio completo

Cosa c'è dopo

break esce completamente dal ciclo. Per saltare solo l'iterazione corrente e continuare con quella successiva, usa continue.

Esercitati