Control del Flujo: Bucles II (break, continue, etiquetas)

Una vez que hemos visto los bucles en Java vamos a ver cómo les afectan las siguientes sentencias: break y continue.

Escribimos un bucle anidado y vemos la diferencia entre break y continue:

public class BucleConBreak{
    public static void main(String[] args){
        for (int i = 0; i< 6; i++){
            for (int j=0; j<5; j++){
                if (j==3){
                    break;
                }
                else{
                    System.out.println("iteracion [i,j]: " + i + ", " + j);
                }
            }
        }
    }
}

El resultado es:

La sentencia break hace que se salga completamente del bucle más interno y proseguimos con la siguiente iteración del bucle externo.

El mismo código pero con continue:

public class BucleConContinue{
     public static void main(String[] args){
         for (int i = 0; i< 6; i++){
             for (int j=0; j<5; j++){
                 if (j==3){
                     continue;
                 }
                 else{
                      System.out.println("iteracion [i,j]: " + i + ", " + j);
                 }
             }
         }
      }
 }

Devuelve:

La sentencia continue hace que pasemos a la siguiente iteración del bucle más interno.

Etiquetas

Es común utilizar las etiquetas con bucles for o while y en conjunción con las sentencias break y continue.

Una etiqueta se coloca antes de la sentencia a etiquetar seguida de ‘:’
Son útiles cuando tenemos bucles anidados y queremos especificar en cuál de ellos queremos hacer un break o continue.

En el siguiente ejemplo tenemos un ejemplo de break etiquetado:
El funcionamiento normal del break sería salir del bucle más interno, el while en este caso.
Sin embargo, el break etiquetado hace que rompa el bucle etiquetado, es decir el for.

public class BucleBreakLabeled{
    public static void main (String[] args){
        boolean esVerdadero = true;
        externo: //etiqueta la siguiente sentencia, es decir el for.
        for (int i = 0; i<5; i++){
            while (esVerdadero){
                System.out.println("Hola!");
                break externo; //break con etiqueta, hace que rompa la sentencia de la etiqueta, el for.
            }
            System.out.println("Despues del while!");
        }
        System.out.println("Despues del for!");
    }
}

Devuelve:

Las sentencias break y continue con etiquetas deben estar dentro de un bucle con la misma etiqueta, si no dará error de compilación.

 

Control del Flujo: Bucles

Los bucles nos permiten alterar el flujo de ejecución de un programa ejecutando repetidamente una sentecia o grupo de sentencias.

En Java 6 tenemos tres opciones distintas a la hora de realizar iteraciones:

• while,
• do while,
• for (normal y mejorado)

Vamos a ver cada una de ellas en detalle.

While

Es el bucle indicado cuando no se sabe de antemano cuántas veces se va a ejecutar el bucle. Simplemente queremos que se repitan ciertas acciones mientras la condición del bucle sea cierta.

//inicialización de variables
while (condicion){   //La condicion debe evaluarse a boolean
    //codigo         //Puede no ejecutarse ninguna vez
}

Cómo funciona:

Al entrar en el while se comprueba la condicion por primera vez.
Si resulta falsa no llega a ejecutar el código y se prosigue la ejecución fuera del bucle.
Si es cierta se ejecuta el código y se vuelve a comprobar la condición.
Así sucesivamente hasta que la condición devuelva falso y salgamos del bucle.

Como veremos la última sentencia que se ejecutará en un bucle siempre será la comprobación de la condición.

Por ejemplo:
En este código la variable i vuelve a incrementarse en la última comprobación de la condición del bucle, cuando ésta ya es falsa.

public class EjemWhile1{
    public static void main (String[] args){
        int i = -1;
        boolean encontrado = false;
        int[] medidas = {10, 30, 40, 50, 70};
        while (++i < 5 && !encontrado){
            if(medidas[i] == 40){
             encontrado = true;
            }
        }
        System.out.println(i);
    }
}

En los bucles while estar atento a:

• Declaración de variables en la condición del while. No se puede, deben estar declaradas con anterioridad.
• Expresiones en la condición del while que no sean boolean.
  Por ejemplo: enteros en lugar de boolean o asignaciones en lugar de comparaciones, darán error de compilación.

Do While

En estos bucles primero se ejecuta el código y luego se comprueba la condición, por lo que tenemos asegurado que el código se ejecuta al menos una vez.

do{
    elem = pila.obtener();
    System.out.println("elem: " + elem);
} while (!pila.esVacia());

Cómo funciona:
En primer lugar se ejecuta el código del bucle.
A continuación se comprueba la condición. Si esta es falsa se prosigue la ejecución fuera del bucle. Si es verdadera se ejecuta el código y se vuelve a comprobar la condición.

Estar atento a las mismas consideraciones que en el while.

For

Es el bucle que solemos utilizar cuando sabemos cuántas veces queremos ejecutar cierto código.

En su sintaxis podemos destacar tres partes importantes:
- declaración e inicialización de variables
- condición
- incremento.

Aunque ninguna de ellas son obligatorias.

Ejemplo de bucle mínimo for:

for ( ; ; ){ //sin inicializacion, condición ni incremento. Sería un bucle infinito.
    //infinito
}

Ejemplo de un bucle for que equivaldría a un while:(sin inicialización ni incremento)

int i = 0;
for ( ; i<10 ; ){
    i++;
}

Ejemplo de un bucle for típico:

for (int i=0;i<10;i++){
    //declaración e inicializacion "int i=0"
    //condicion "i<10"
    //incremento "i++"
    System.out.println("i: " + i);
}

Cómo funciona:

La inicialización de la variable se ejecuta al principio una sola vez.
A continuación se comprueba la condición y si es falsa se prosigue la ejecución fuera del bucle.
Si resulta cierta se ejecuta el código, se incrementa la variable y se vuelve a comprobar la condición.

Consideraciones del For.

Declaración e inicialización:

• Se pueden declarar 0, 1 o más variables del mismo tipo. Si hay más de una se separan por comas.
• Las variables declaradas en el for pierden su ámbito al salir del bucle for.
• Esta parte sólo se ejecuta una vez, al principio de la ejecución del bucle.

Condición:

• Sólo se puede comprobar una condición no varias.

Incremento:

• Se ejecuta despúes de que se ejecute el código del for.

For “Mejorado”

Simplifica recorrer un array o una colección. Tiene dos partes, la declaración y el elemento a recorrer.

int[] array = {10,20,30,50};
for (int elem: array){
    System.out.println("elem: " + elem);
}

En la declaración: hay que declarar una variable compatible con el tipo de los elementos del array o de la colección.

En la expresión: será una variable array, colección o un método que las retorne.