Sentencia break en Java

break es la salida de emergencia. Detiene inmediatamente el bucle más interno o el bloque switch en el que se encuentra, y la ejecución continúa con lo que sigue a continuación. Úsalo cuando el trabajo del bucle haya terminado y no haya razón para seguir iterando.

Salir de un bucle

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

Imprime 0 1 2 3 4 y termina. La condición del bucle (i < 100) y la actualización (i++) se abandonan en el momento en que se ejecuta break.

Un uso típico: buscar un elemento y detenerse en cuanto lo encuentres:

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);

Sin break, seguirías comprobando elementos que ya sabes que no son la respuesta.

break en un while

Funciona de forma idéntica en while y do/while:

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

while (true) { ... break; } es el patrón estándar para "iterar hasta que alguna condición decidida dentro del cuerpo sea verdadera".

break en un switch

En una sentencia switch tradicional, break sale del switch — evitando la caída al siguiente caso. Lo viste en el capítulo sobre switch:

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

Las expresiones switch de forma con flecha tratadas en expresiones switch no tienen caída, por lo que no necesitan break.

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

Para salir del bucle desde dentro del switch, necesitas un break con etiqueta (mostrado a continuación) o un indicador que el bucle compruebe después.

break solo sale un nivel

break sale del bucle o switch más interno que lo encierra. En bucles anidados, solo sale del interior:

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);
  }
}

Salida:

0,0
1,0
2,0

Para salir de todos los bucles anidados a la vez, usa un break con etiqueta — tratado en sentencias con etiqueta:

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

Si el trabajo que viene después del bucle es significativo, usa break. Si el método no tiene nada más que hacer una vez que el bucle termina, simplemente usa return directamente:

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

Ambos son correctos. return suele ser la opción más clara para métodos de tipo búsqueda.

Un ejemplo completo

¿Qué sigue?

break sale del bucle completamente. Para omitir solo la iteración actual y continuar con la siguiente, usa continue.

Práctica