Continuamos con las estructuras de control. En este tema explicaremos la estructura repetitiva en java, también llamada estructura iterativa o simplemente bucles o ciclos.

La estructura repetitiva o iterativa permite ejecutar varias veces una instrucción o un bloque de instrucciones.

Las instrucciones se repiten mientras se cumpla una determinada condición. Esta condición se conoce como condición de salida del bucle.

Cuando la condición deja de cumplirse, el bucle finaliza y la ejecución del programa continúa por la siguiente instrucción después del bucle.

Mediante las estructuras repetitivas nos evitamos escribir las mismas instrucciones una y otra vez. Por ejemplo, si queremos mostrar los números del 1 al 10 por pantalla, podríamos escribir 10 instrucciones System.out.println(), una para cada número. Sin embargo, utilizando una estructura repetitiva podemos conseguir el mismo resultado con un código más compacto.

La estructura repetitiva en Java se implementa mediante las siguientes instrucciones:

• bucle while
• bucle do .. while
• bucle for

Java proporciona además el bucle for-each que es una modalidad de bucle for para recorrer arrays y colecciones de objetos.

El bucle while permite ejecutar un bloque de instrucciones mientras se cumpla una determinada condición.

Se utiliza cuando necesitamos repetir una operación y no sabemos de antemano cuántas veces será necesario hacerlo.

Por ejemplo, podemos utilizar un bucle while para solicitar al usuario que introduzca un número positivo, para introducir una contraseña, etc. Mientras el valor introducido no sea válido se repetirá el proceso.

El bucle while se puede representar mediante diagrama de flujo de esta forma:

En los bucles while las instrucciones se ejecutan mientras se cumpla la condición. Funciona de la siguiente forma:

1. Se evalúa la condición.
2. Si la condición es true se ejecutan las instrucciones y se vuelve al paso 1.
3. Si la condición es false las instrucciones no se ejecutan y el programa continúa por la siguiente instrucción a continuación del while.

Importante: Un bucle while puede ejecutarse cero o más veces. Una de sus características más importantes es que la condición en el bucle while se evalúa antes de ejecutar el bloque de instrucciones. Por este motivo, si la condición es falsa desde el principio, las instrucciones que forman el while no llegarán a ejecutarse.

La sintaxis de un bucle while es la siguiente:

Un bucle while se crea mediante la palabra reservada while seguida por la condición entre paréntesis. A continuación se escriben entre llaves las instrucciones que se deben repetir mientras la condición sea cierta.

Si el bloque de instrucciones está formado por una sola instrucción se pueden omitir las llaves aunque es recomendable escribirlas siempre para facilitar la lectura del código y evitar errores de lógica.

Ejemplo 1:

Mostrar por pantalla los números del 1 al 5.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle while
 * Programa que muestra por pantalla los números del 1 al 5
 */
public class EjemploWhile1 {
    public static void main(String[] args) {
        int numero = 1;  //variable cuyo valor se mostrará por pantalla. El valor inicial es 1
        while (numero <= 5) { //inicio del bucle while. Se repetirá mientras numero <= 5
            System.out.println(numero);  //se muestra el valor de la variable numero
            numero++; //se incrementa el valor de la variable numero
        } // fin del bucle while
        System.out.println("Fin programa");
    }
}

El programa funciona de la siguiente forma:

Primero se declara la variable número y se le asigna el valor 1.

A continuación llegamos al inicio del bucle while con la instrucción

while (numero <= 5) {

La variable número es la variable de control que determina cuando finaliza el bucle.

La condición que se debe cumplir para que el bucle se repita es numero <= 5

Mientras el valor de numero sea menor o igual a 5 las instrucciones del bucle se ejecutarán.

Dentro del bucle hay dos instrucciones:

• System.out.println(numero); que muestra por pantalla el valor de la variable numero
• numero++; que incrementa el valor de numero en cada iteración del bucle. Esta instrucción es fundamental para que el programa funcione de forma correcta ya que hace que en cada vuelta del bucle el valor de numero se incremente en 1.

Cuando se ejecutan estas dos instrucciones se vuelve a evaluar la condición.

Cuando la variable numero alcance el valor 6 la condición dejará de ser cierta y el bucle finaliza.

Salida por pantalla:

1
2
3
4
5
Fin programa

Si nos olvidamos de escribir la instrucción numero++; el valor de la variable numero siempre será 1. La condición será verdadera siempre y el programa entraría en un bucle infinito.

Ejemplo 2:

Programa que pide introducir números enteros por teclado. La lectura de números termina cuando se introduce un número negativo. El programa muestra la suma de todos los números introducidos excepto el negativo.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle while
 * Programa que lee números por teclado hasta introducir un número negativo
 * Muestra la suma de los números introducidos excepto el negativo
 */
import java.util.Scanner;
public class EjemploWhile2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num; //variable que contiene el número introducido
        int suma = 0; //variable donde acumularemos la suma de los números
        System.out.print("Introduzca un número ( < 0 para finalizar ): ");
        num = sc.nextInt(); //lectura del primer número
        while (num >= 0) { //inicio del bucle while
            suma = suma + num; //se suma el número introducido
            System.out.print("Introduzca un número ( < 0 para finalizar ): ");
            num = sc.nextInt(); //lectura del siguiente número
        } //fin del bucle while
        System.out.println("La suma es: " + suma); //se muestra la suma
    }
}

En este programa, según el enunciado, se trata de leer números enteros por teclado hasta que se introduzca un número negativo, por lo tanto, la condición que se debe cumplir para que se repitan las instrucciones contenidas dentro del while es:

num >= 0

La condición se escribe entre paréntesis a continuación de la palabra while:

 while (num >= 0) {

Mientras el número introducido sea mayor o igual a 0 se repite el bucle.

Este es un ejemplo de estructura repetitiva en el que no sabemos a priori cuántas veces se repetirán las instrucciones. El número de iteraciones del bucle depende del valor de la variable num que se introduce por teclado.

En el ejemplo podemos ver también que la lectura del primer número se realiza antes de que comience la estructura while. Hay que hacerlo así porque es posible que el primer número que se introduzca sea el negativo, en ese caso no tendríamos que sumarlo, por lo tanto el while no se debe ejecutar y se muestra directamente el mensaje con la suma del número.

Esta técnica se conoce como lectura adelantada o anticipada y es la forma correcta de utilizar la estructura while cuando no sabemos el número de iteraciones que se van a realizar.

Dos ejemplos de ejecución del programa:

Introduzca un número ( < 0 para finalizar ): 6
Introduzca un número ( < 0 para finalizar ): 2
Introduzca un número ( < 0 para finalizar ): 5
Introduzca un número ( < 0 para finalizar ): -1
La suma es: 13

En este caso se introducen los números 6, 2 y 5. Cuando se introduce el valor -1 el bucle finaliza y se muestra la suma.

Introduzca un número ( < 0 para finalizar ): -2
La suma es: 0

En este ejemplo de ejecución el primer número introducido es negativo por lo que el bucle while no se ejecuta.

Se muestra el resultado de la suma que en este caso será 0.

Ejemplo 3:

Programa que muestra N asteriscos por pantalla. El valor de N se introduce por teclado.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle while
 * Programa que muestra N asteriscos por pantalla
 */
import java.util.Scanner;
public class EjemploWhile3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N; //variable que contiene el número de asteriscos a mostrar
        int contador = 0; //variable para contar los asteriscos que se han mostrado
        System.out.print("Introduce número de asteriscos a mostrar: ");
        N = sc.nextInt(); //leemos el número total de asteriscos a mostrar
        while (contador < N) { //inicio del bucle while
            System.out.print("*");
            contador++;
        } //fin del bucle while
        System.out.println("\nFin programa");
    }
}

En este programa sí sabemos a priori cuántas veces se va a repetir el bucle: el while se repetirá N veces.

La condición que se debe cumplir para que el bucle se ejecute es:

 contador < N

La variable contador es la variable de control del bucle que hará que el while finalice.

Cada vez que se muestra un asterisco por pantalla se suma 1 a la variable contador. El while se repite mientras el valor del contador sea menor que el número total de asteriscos a mostrar N.

Dos ejemplos de ejecución:

Introduce número de asteriscos a mostrar: 10
**********
Fin programa

Introduce número de asteriscos a mostrar: 0
Fin programa

Si se introduce un 0 en el número de asteriscos a mostrar, la condición while (contador < N) no se cumple ya que el valor inicial de contador es 0. En este caso el bucle no se ejecuta y se pasa directamente a la última instrucción del programa.

Ejemplo 4:

Programa que muestra una tabla con temperaturas expresadas en grados Fahrenheit y su equivalente en grados Celsius. Los valores de las temperatura en grados Fahrenheit estarán comprendidas entre 10 ºF y 100 ºF y se mostrarán con un incremento de 10º entre ellas (10, 20, 30 …).

La fórmula para pasar de ºF a ºC: ºC = (ºF – 32) * 5 / 9

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle while
 * Programa que muestra una tabla de temperaturas en ºF y su equivalente en ºC
 */
public class EjemploWhile4 {
    public static void main(String[] args) {
        int fahrenheit = 10; //contiene las temperaturas fahrenheit
        double celsius; //contiene las temperaturas celsius
        System.out.printf(" ºF \t ºC \n");
        System.out.println("---------------");
        while (fahrenheit <= 100) { //inicio del bucle while
            celsius = (fahrenheit - 32) * 5 / 9.0;
            System.out.printf("%3d\t%6.2f \n", fahrenheit, celsius);
            fahrenheit += 10;
        } //fin del bucle while
    }
}

En este ejemplo la variable fahrenheit es la variable de control y será la encargada de determinar cuando finaliza el bucle while. Su valor inicial es 10 y se deben mostrar las temperaturas desde 10ºF hasta 100ºF de 10 en 10, por lo tanto en cada iteración se incrementará su valor en 10.

El while se repite mientras el valor de la variable sea <= 100.

 ºF       ºC 
---------------
 10	  -12,22 
 20	   -6,67 
 30	   -1,11 
 40	    4,44 
 50	   10,00 
 60	   15,56 
 70	   21,11 
 80	   26,67 
 90	   32,22 
100	   37,78 

El bucle do .. while es otra estructura repetitiva en Java que permite repetir la ejecución de instrucciones mientras se cumpla una condición.

La principal diferencia con el bucle while es que la condición se evalúa al final por lo que el bucle do .. while se ejecuta al menos una vez.

Representación mediante diagrama de flujo del bucle do .. while:

Los bucles do .. while funcionan de la siguiente forma:

1. Se ejecutan las instrucciones que contiene.
2. Se evalúa la condición.
3. Si la condición se cumple volvemos al paso 1.
4. Si la condición no se cumple, el bucle finaliza y el programa continúa por la siguiente instrucción a continuación del bucle.

Importante: Un bucle do .. while se ejecuta una o más veces. En un do .. while primero se ejecutan las instrucciones que contiene el bucle y al final se comprueba la condición por lo que las instrucciones se ejecutarán al menos 1 vez.

La sintaxis del bucle do .. while es esta:

do es la palabra reservada que indica el inicio del bucle do .. while.

A continuación se escribe entre llaves { } la instrucción o bloque de instrucciones que se deben repetir.

A continuación de la llave de cierre del bloque de instrucciones se escribe la palabra reservada while seguida de la condición entre paréntesis.

Después de la condición se escribe el carácter ;

Ejemplo 1:

En un ejemplo anterior hemos visto como mostrar los números del 1 al 5 mediante un bucle while. En este ejemplo vamos a utilizar un bucle do .. while para mostrarlos.

Programa que muestra los número del 1 al 5 mediante do .. while

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle do while
 * Programa que muestra los números del 1 al 5
 */
public class EjemploDoWhile1 {
    public static void main(String[] args) {
        int numero = 1;  //variable cuyo valor se mostrará por pantalla. El valor inicial es 1
        do { //inicio del bucle do while
            System.out.println(numero); //se muestra el valor de la variable numero
            numero++; //se incrementa el valor de la variable numero
        } while (numero <= 5); // fin del bucle do .. while. Se repetirá mientras numero <= 5
        System.out.println("Fin programa");
    }
}

El funcionamiento del programa es el siguiente:

La instrucción int numero = 1; declara la variable numero y se le asigna el valor inicial 1.

A continuación llegamos al inicio del bucle do .. while con la instrucción do{

Después aparecen las dos instrucciones que se ejecutan en cada iteración del bucle:

• System.out.println(numero); muestra el valor de la variable numero
• numero++; incrementa el valor de la variable numero. En cada iteración del bucle el valor de numero se incrementa en 1.

La llave } marca el final del bloque de instrucciones a ejecutar en el bucle.

Después se evalúa la la condición que se debe cumplir para que el bucle se ejecute de nuevo:

while (numero <= 5);

Mientras el valor de numero sea menor o igual a 5 el bloque de instrucciones a partir de do { se volverán a ejecutar. Cuando la variable numero alcance el valor 6 la condición dejará de ser cierta y el bucle finaliza.

Salida por pantalla:

1
2
3
4
5
Fin programa

Ejemplo 2:

El hecho de que el bucle do .. while se repita al menos una vez lo hace especialmente adecuando cuando se trata de introducir datos por teclado ya que en estos casos primero se introduce un valor y después se comprueba si el dato introducido es válido o no. Si no es válido se vuelve a pedir. La comprobación de si el dato es válido o no se evalúa al final, una vez introducido el dato, es decir, las instrucciones del bucle se ejecutan siempre al menos una vez.

En este ejemplo veremos un caso práctico de lectura de datos por teclado, comprobando que el dato sea válido.

Programa que pide al usuario que introduzca un número positivo y muestra su raíz cuadrada.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle do while
 * Programa que lee un número entero positivo y muestra su raíz cuadrada
 */
import java.util.Scanner;
public class EjemploDoWhile2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N;
        do { //inicio del do .. while
            System.out.print("Introduce un número entero > 0: ");
            N = sc.nextInt();
        } while (N <= 0); //fin del do .. while
        System.out.println("Raíz cuadrada de " + N + " -> " + Math.sqrt(N));
    }
}

En este programa las instrucciones para pedir al usuario que introduzca un número por teclado se han escrito dentro de un bucle do .. while. Cuando se entra al bucle estas instrucciones se ejecutan y después se comprueba si el número introducido es correcto.

Para que el número N sea válido debe ser positivo. Si no es positivo debemos volver a pedirlo.

La condición while (N <= 0) está indicando que mientras que el número introducido N sea menor o igual a cero se debe volver a pedir.

Cuando se introduce un número válido (número positivo) la condición N <= 0 deja de cumplirse y el bucle finaliza.

Se muestra por pantalla el mensaje con el valor de N y su raíz cuadrada.

Ejemplo de ejecución:

Introduce un número entero > 0: -9
Introduce un número entero > 0: 0
Introduce un número entero > 0: 2
Raíz cuadrada de 2 -> 1.4142135623730951

Debemos tener cuidado cuando escribamos la condición en los bucles do .. while. A veces podemos confundirnos y expresar la condición de forma incorrecta. Por ejemplo, en el caso de pedir un número positivo, escribir la condición como while(N > 0) Escribir la condición así supone que el bucle se repetirá mientras el número sea positivo, justo lo contrario de lo que queremos.

Este error a la hora de expresar la condición suele deberse a pensar en el bucle do .. while como un repetir hasta que se cumpla la condición como sucede en otros lenguajes.

Lenguajes como Perl, Ruby o Visual Basic tienen una estructura repetitiva como el do .. while de Java pero con una lógica de finalización inversa. En estos lenguajes el bucle se repite hasta que la condición se cumple. En estos lenguajes la condición sería N > 0. Pero en Java en bucle se repite mientras la condición se cumple lo que hace que la condición se deba escribir N <= 0.

Ejemplo 3:

Programa para convertir grados a radianes. Se pide al usuario que introduzca un ángulo en grados entre 0 y 360 ambos incluidos y calcula su equivalente en radianes. Si el ángulo introducido no es válido se muestra un mensaje indicándolo y se vuelve a pedir. Finalmente se muestra por pantalla el equivalente del ángulo en radianes.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle do while
 * Programa para pasar un ángulo de grados a radianes
 */
import java.util.Scanner;
public class EjemploDoWhile3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double grados;
        double radianes;
        do { //inicio bucle do .. while
            System.out.print("Introduce un ángulo entre 0 y 360 grados: ");
            grados = sc.nextDouble();  //se introduce un ángulo en grados
            if(grados < 0 || grados > 360){ // si los grados no son válidos se muestra un mensaje de error
                System.out.println("Valor no válido. Debe ser entre 0 y 360");
            }
        } while (grados < 0 || grados > 360); //fin do while. Se repite mientras los grados no sean válidos
        radianes = Math.toRadians(grados);  //cálculo de los radianes 
        System.out.println(grados + " grados equivalen a " + radianes + " radianes."); //mostrar resultados
    }
}

Dentro del do .. while se pide al usuario que se introduzca un valor en grados que debe ser entre 0 y 360 ambos incluidos.

Si el valor introducido para los grados no es válido se muestra el mensaje «Valor no válido. Debe ser entre 0 y 360» y se llega a la instrucción final del bucle donde la condición no se cumple y se vuelve a repetir el bucle. En este tipo de programas donde se pide un dato por teclado, si no es válido se muestra un mensaje de error y se vuelve a pedir, la condición en el if para mostrar el mensaje de error y la condición en el while para repetir las instrucciones debe ser la misma.

Si el valor introducido para los grados es válido la condición del if no se cumple. Se llega al final del while donde la condición es la misma y por lo tanto tampoco se cumple. El while finaliza y se muestra el mensaje con los grados introducidos y los radianes equivalentes.

En este ejemplo para pasar a radianes se ha utilizado el método toRadians de la clase Math de Java: Math.toRadians(grados)

También se podría haber hecho el cálculo utilizando la fórmula para pasar de grados a radianes: grados * π / 180

Igual que los bucles while y do .. while, un bucle for es otra estructura repetitiva en Java que permite que la ejecución de una serie de instrucciones se repita mientras se cumpla una determinada condición.

Los bucles for son los más adecuados cuando se conoce el número de veces que se van a repetir las instrucciones. Por ejemplo, podemos utilizar un bucle for para mostrar una secuencia determinada de números, introducir por teclado una cantidad determinada de valores, recorrer las posiciones de un array o realizar la misma operación un número determinado de veces.

La representación en diagrama de flujo de un bucle for:

Los bucles for en Java funcionan de esta forma:

1. Se inicializa la variable o variables de control del bucle.
2. Se evalúa la condición.
3. Si la condición es falsa, finaliza la ejecución del for y el programa continúa su ejecución en la siguiente instrucción después del for.
4. Si la condición es cierta se ejecutan las instrucciones contenidas dentro del for.
5. Se realiza la modificación de la variable de control que generalmente será un incremento o decremento de su valor y se vuelve al paso 2.

Importante: En los bucles for la inicialización se ejecuta una sola vez. La condición se comprueba antes de cada posible iteración y la actualización de la variable de control se realiza al finalizar cada iteración.

Importante: Como ocurre con el bucle while, un bucle for se puede ejecutar cero o más veces. Si al iniciar el for la condición es falsa el bucle no llegará a ejecutarse.

La sintaxis del bucle for en Java es esta:

for es la palabra reservada que indica el inicio del bucle.

A continuación de la palabra for aparece entre paréntesis la cabecera del bucle.

La cabecera contiene tres zonas separadas por el carácter ; :

• Inicialización: es la parte en la que la variable o variables de control del bucle toman su valor inicial. Puede haber una o más instrucciones en la zona de inicialización. Si hay varias instrucciones deben estar separadas por comas. La inicialización se realiza solo una vez.
• Condición: es una expresión booleana que determina si la sentencia o bloque de sentencias se ejecutan o no. Las instrucciones contenidas dentro del bucle for se ejecutan mientras que la condición sea cierta.
• Incremento/decremento: también llamada actualización. En esta parte se escribe una expresión que modifica la variable o variables de control del bucle. En esta zona puede haber más de una expresión para modificar las variables. Si hay varias expresiones deben estar separadas por comas. Esta parte se ejecuta siempre a continuación de ejecutar las instrucciones del bucle.

Las tres zonas de la cabecera del bucle for son opcionales. Si en alguna ocasión no fuese necesario escribir alguna de estas zonas se pueden dejar en blanco, pero los punto y coma deben aparecer.

A continuación de la cabecera entre llaves { } se escriben las instrucciones que se deben ejecutar.

Como en el resto de bucles, si solo se ejecuta una instrucción dentro del bucle las llaves se pueden omitir aunque siempre es recomendable escribirlas.

Una de sus principales ventajas del bucle for es que reúne en la cabecera todos los elementos que controlan la repetición: la inicialización de la variable, la condición que determina cuándo finaliza el bucle y la actualización de dicha variable. Esto facilita la lectura del código y escribir código más compacto.

Ejemplo 1:

Empezamos con el mismo ejemplo realizado para los bucles while y do .. while. Escribir el programa para mostrar los números del 1 al 5 utilizando ahora la estructura repetitiva for.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle for
 * Programa que muestra los números del 1 al 5
 */
public class EjemploFor1 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {  // inicio del bucle for
            System.out.println(i);
        } // fin del bucle for
        System.out.println("Fin programa");
    }
}

La ejecución de la instrucción for en este programa sigue este orden:

1. La ejecución del for comienza en la zona de inicialización donde se declara la variable i de tipo int, que es la variable de control del bucle, y se le asigna el valor inicial 1.
2. A continuación se comprueba la condición i <= 5.
3. Si la condición no se cumple el for finaliza y la ejecución continúa por la siguiente instrucción después del bucle. En este caso se ejecuta la instrucción System.out.println("Fin programa"); y el programa finaliza.
4. Si la condición se cumple se ejecuta la instrucción System.out.println(i); que muestra por pantalla el valor de i.
5. A continuación se pasa a la zona de incremento/decremento donde se incrementa el valor de i
6. Después de incrementar el valor de i volvemos al punto 2 para comprobar de nuevo la condición.

El for se repite mientras el valor de i sea menor o igual a 5. Cuando la variable i alcance el valor 6 la condición dejará de cumplirse y el bucle finaliza.

Se muestra por pantalla:

1
2
3
4
5
Fin programa

Si comparamos este código para mostrar los números del 1 al 5 con los programas realizados con los bucles while y do .. while podemos ver que con el bucle for se obtiene un código más compacto por que reúne en la cabecera todos los elementos que controlan la repetición del bucle: la inicialización de la variable de control, la condición que determina si el bucle se continúa ejecutando y la actualización de la variable de control.

En los programas de este tipo en los que la variable de control, en este caso la i, solo se utiliza dentro del bucle for es habitual declararla en la zona de inicialización como se ha hecho aquí int i = 1. Pero no siempre es obligatorio hacerlo así. La variable de control puede haberse declarado anteriormente fuera del bucle.

Si la variable del control ya está declarada fuera del bucle, la cabecera del for se escribiría así:

 for (i = 1; i <= 5; i++) {

en este caso solo se le da un valor pero sin declararla.

Ejemplo 2:

Programa que muestra por pantalla los números del 5 al 1.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle for
 * Programa que muestra los números del 5 al 1
 */
public class EjemploFor2 {
    public static void main(String[] args) {
        for (int i = 5; i >= 1; i--) { //inicio del bucle for
            System.out.println(i);
        } // fin del bucle for
        System.out.println("Fin programa");
    }
}

En este programa se muestran los números hacia atrás del 5 al 1. El funcionamiento del for es el mismo que se ha explicado en el ejemplo anterior. En este caso la variable de control se inicializa con el valor 5 que es el primer valor que queremos mostrar por pantalla. En cada iteración del bucle la variable se decrementa en 1. El bucle se repite mientras la condición i >= 1 sea verdadera. Cuando la variable i alcance el valor 0 la condición será falsa el bucle dejará de ejecutarse.

Ejemplo 3:

Programa que lee por teclado 10 números y calcula la media de los números introducidos.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle for
 * Programa que lee 10 números por teclado y muestra su media
 */
public class EjemploFor3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double numero, suma = 0, media;
        for (int i = 1; i <= 10; i++) { // inicio del bucle for
            System.out.print("Numero " + i + ": ");
            numero = sc.nextDouble();
            suma += numero;
        } // fin del bucle for
        media = suma / 10;
        System.out.println("Media: " + media);
        System.out.println("Fin programa");
    }
}

Al principio del for se crea la variable i de tipo int y se le asigna el valor 1. El bucle for se ejecuta mientras se cumpla la condición i <= 10. En cada iteración el valor de i se incrementa en 1. Cuando i alcance el valor 11 la condición deja de cumplirse. El bucle finaliza y la ejecución del programa continúa por las instrucciones a continuación del for.

En cada iteración del bucle se ejecutan tres instrucciones:

• System.out.print("Numero " + i + ": "); que muestra por pantalla «Numero » seguido del valor de i en ese momento
• numero = sc.nextDouble(); que introduce por teclado un valor de tipo double y lo almacena en la variable numero
• suma += numero; que acumula en la variable suma el valor introducido por teclado

Cuando finaliza el bucle se ejecutan las instrucciones:

• media = suma / 10; que calcula la media de los 10 valores introducidos
• System.out.println(«Media: » + media); para mostrar la media de los números introducidos por teclado
• System.out.println(«Fin programa»);

Ejemplo de ejecución:

Numero 1: 5,9
Numero 2: 2,77
Numero 3: 10
Numero 4: -22,578
Numero 5: 8
Numero 6: 14
Numero 7: 330,7
Numero 8: 2,0089
Numero 9: 42,99
Numero 10: 0,88
Media: 39.46709
Fin programa

Ejemplo 4:

Vamos a hacer de nuevo el programa que muestra una tabla con temperaturas expresadas en grados Fahrenheit y su equivalente en grados Celsius pero esta vez utilizaremos un bucle for para resolverlo. El programa debe realizar los mismo que el realizado con el bucle while: los valores de las temperatura en grados Fahrenheit estarán comprendidas entre 10 ºF y 100 ºF y se mostrarán con un incremento de 10º entre ellas (10, 20, 30 …).

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle for
 * Tabla de temperaturas en grados Fahrenheit y su equivalente en grados Celsius
 */
public class EjemploFor4 {
    public static void main(String[] args) {
        double celsius;
        System.out.printf(" ºF \t ºC \n");
        System.out.println("---------------");
        for (int fahrenheit = 10; fahrenheit <= 100; fahrenheit += 10) {
              celsius = (fahrenheit - 32) * 5 / 9.0;
              System.out.printf("%3d\t%6.2f \n", fahrenheit, celsius);
         }
    }
}

 ºF     ºC 
---------------
 10	-12,22 
 20	 -6,67 
 30	 -1,11 
 40	  4,44 
 50	 10,00 
 60	 15,56 
 70	 21,11 
 80	 26,67 
 90	 32,22 
100	 37,78

La instrucción for se ejecuta de esta forma:

En la zona de inicialización se crea la variable fahrenheit de tipo int y se le asigna el valor inicial 10.

A continuación se comprueba la condición fahrenheit <= 100. Mientras que el valor de fahrenheit sea menor o igual que 100 se ejecutan las instrucciones del for.

A continuación se incrementa el valor de fahrenheit en 10 mediante la instrucción fahrenheit += 10 y se comprueba de nuevo la condición.

El bucle for finaliza cuando la variable fahrenheit tenga un valor mayor que 100.

Ejemplo 5:

La zona de inicialización del bucle for puede contener varias variables a las que se les da un valor inicial al principio del for. Las variables en este caso tienen que ir separadas poro comas. Lo mismo ocurre en la zona de incremento/decremento donde se puede modificar el valor de varias variables, separadas por comas.

Vamos a ver un ejemplo de programa que utiliza varias variables en las zonas de inicialización e incremento/decremento.

Programa que muestre la siguiente tabla de potencias: 9⁰, 8¹, 7², 6³, 5⁴, 4⁵, 3⁶, 2⁷, 1⁸

Se trata de mostrar una tabla que muestre los números del 9 al 1 elevados del o al 9.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle for
 * Programa que muestra una tabla de potencias
 */
public class EjemploFor5 {
    public static void main(String[] args) {
        for(int base = 9, exponente = 0; base > 0; base--, exponente++){
            System.out.println(base + " ^ " + exponente + " = " + Math.pow(base, exponente));
        }
    }
}

En la zona de inicialización se han declarado dos variables de tipo int: base con el valor inicial 9 y exponente con el valor inicial 0.

La condición que debe cumplirse para que el bucle se ejecute es base > 0. Mientras que el valor de la variable base sea > 0 la condición será cierta y se ejecutará la instrucción:

System.out.println(base + " ^ " + exponente + " = " + Math.pow(base, exponente));

que muestra el valor de base y exponente en cada iteración y el resultado de la calcular base^exponente

En la zona de incremento/decremento se decrementa el valor de base y se incrementa el valor de exponente.

Cuando el valor de la variable base sea 0 la condición deja de cumplirse y el bucle finaliza.

Se muestra por pantalla:

9 ^ 0 = 1.0
8 ^ 1 = 8.0
7 ^ 2 = 49.0
6 ^ 3 = 216.0
5 ^ 4 = 625.0
4 ^ 5 = 1024.0
3 ^ 6 = 729.0
2 ^ 7 = 128.0
1 ^ 8 = 1.0

La cabecera del bucle for en Java contiene tres zonas separadas por el carácter punto y coma: zona de inicialización, zona de condición y zona de modificación o de incremento/decremento.

Las tres zonas son opcionales. En un bucle for en java, se puede omitir alguna de las zonas pero la separación con ; debe mantenerse.

La cabecera de un bucle for siempre debe contener dos ; separando las tres zonas aunque alguna de ellas esté vacía.

La zona de inicialización se puede dejar vacía si la variable de control del bucle ya está declarada anteriormente y tiene asignado un valor.

Ejemplo:

int numero = 1;
for ( ; numero <= 5;  numero++) {
       System.out.println(numero);
}

La variable numero se declara e inicializa antes del bucle. Por eso, zona de inicialización del bucle se deja vacía pero se mantiene el primer punto y coma que indica la separación entre la zona de inicialización y la condición.

Esta forma de escribir el for resulta útil cuando necesitamos asignar un valor a la variable antes del bucle o queremos reutilizar una variable que ya se ha utilizado anteriormente en el programa.

Se puede omitir las operaciones en la zona de actualización si la variable de control se modifica dentro del bloque de instrucciones del for.

Ejemplo:

for (int numero = 1; numero <= 10;  ) {
      System.out.println(numero++);
}

Este for muestra los números del 1 al 10. La zona de actualización en la cabecera se ha omitido porque la modificación de la variable numero se realiza en la propia instrucción que lo muestra por pantalla.

System.out.println(numero++);

En esta instrucción se muestra el valor de la variable numero y se incrementa su valor mediante numero++. De esta forma ya no es necesario hacer el incremento en la cabecera del bucle. Si por error escribimos de nuevo este incremento en la cabecera estaríamos incrementando la variable numero dos veces en cada iteración del bucle.

También es posible omitir ambas zonas cuando la variable de control ya se ha declarado e inicializado anteriormente y se modifica dentro de las instrucciones que contiene el for.

Ejemplo:

int numero = 1;
for ( ; numero <= 10; ) {
      System.out.println(numero++);
}

En este ejemplo también se muestran los números del 1 al 10. La cabecera de este bucle for solo contiene la condición numero <= 10. La zona de inicialización está vacía por que la variable numero se ha declarado e inicializado antes del for. La zona de incremento/decremento también está vacía porque la variable numero se incrementa en la misma instrucción que muestra su valor por pantalla.

Si omitimos la zona de inicialización y la zona de modificación, el bucle for actúa igual que un bucle while. De hecho, en estos casos es recomendable sustituirlo por un bucle while :

int numero = 1;
while(numero <= 10) {
      System.out.println(numero++);
}

El resultado es el mismo, pero el código expresa de forma más natural la lógica del algoritmo: mientras se cumpla la condición, ejecuta las instrucciones y aumenta el valor de la variable.

La condición en un bucle for también puede omitirse. Cuando esto sucede, no hay ninguna condición que determine si el for debe continuar ejecutándose por lo que el bucle se repetirá indefinidamente. La forma de interrumpir este bucle infinito es normalmente la instrucción break.

Ejemplo:

Este programa lee por teclado números enteros hasta que se introduce un cero. Después muestra la suma de los números introducidos.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle for sin condición
 * Leer número hasta introducir un cero y mostrar la suma y al media
 */
import java.util.Scanner;
public class EjemploFor {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int numero, suma = 0;
        for  ( ; ; ) {
            System.out.print("Introduce un número (0 para terminar): ");
            numero = sc.nextInt();
            if (numero == 0) {
                break;
            }
            suma = suma + numero;
        }
        System.out.println("Suma : " + suma);
    }
}

En este ejemplo, la cabecera del bucle for ( ; ; ) omite las tres zonas: inicialización, condición y actualización. Si la condición se convierte en un bucle infinito. Para finalizarlo se ha incluido la instrucción break. Cuando el usuario introduce 0 la instrucción break provoca la salida del bucle y el programa continúa su ejecución a continuación del for.

Esta forma de utilizar un for puede resultar útil cuando la condición de salida no puede expresarse de manera sencilla en la cabecera. En condiciones normales se debería evitar el uso de break para salir de un bucle.

La instrucción break es una instrucción de salto. Las instrucciones de salto se explican en el siguiente punto.

El bucle for-each permite recorrer los elementos de un array o de una colección de objetos sin necesidad de gestionar un índice o una variable de control.

No es una estructura de control independiente de las otras tres estructuras repetitivas en java (while, do .. while, for). El bucle for-each es una variante del bucle for diseñado para recorrer de forma sencilla una estructura de datos.

Esta alternativa al bucle for resulta especialmente útil cuando se desea procesar todos los elementos de una estructura de datos y no es necesario conocer su posición. Por ejemplo, permite mostrar los valores de un array, calcular la suma de sus elementos o recorrer una lista de nombres mediante un código más sencillo.

La sintaxis del bucle for-each en Java es la siguiente:

Para crear un bucle for-each se utiliza la palabra reservada for igual que en la estructura for tradicional.

A condición de la palabra for, entre paréntesis se escribe la cabecera del bucle. La cabecera de un bucle for-each contiene lo siguiente:

• tipo es el tipo de dato de los elementos que se van a recorrer.
• variable un nombre de variable que será la que reciba el valor del elemento actual en cada iteración.
• Carácter : que debe aparecer entre el nombre de la variable y el nombre de la colección.
• nombreColección es el nombre del array o de la colección de objetos que vamos a recorrer.

A continuación de la cabecera, entre llaves { } se escriben las instrucciones que se deben repetir en cada iteración.

El funcionamiento del bucle for-each es diferente al del for tradicional.

Aunque ambos permiten repetir un bloque de instrucciones, en el for tradicional el programador se encarga del control de las iteraciones mediante una variable de control, una condición para finalizar el bucle y una expresión que actualiza la variable de control en cada iteración. En cambio, en un bucle for-each es Java quien se encarga del control de las iteraciones.

El bucle for-each recorre automáticamente los elementos de un array o de una colección. En cada iteración asigna el valor del elemento a la variable declarada en la cabecera. A diferencia del for tradicional, el bucle for-each obtiene automáticamente cada elemento durante el recorrido, sin necesidad de gestionar un índice.

El bucle finaliza cuando se llega al último elemento.

También se puede finalizar el for-each incluyendo una instrucción de salto break o return dentro del bucle. Las instrucciones de salto se explican en el punto siguiente.

Aunque el for-each simplifica el recorrido de arrays y colecciones, conviene tener en cuenta algunas limitaciones:

• No proporciona un índice. Si se necesita conocer la posición de cada elemento, es preferible utilizar un for tradicional.
• Se recorren todos los elementos hasta llegar al final, salvo que se interrumpa el recorrido mediante una instrucción break o return.
• Puede utilizarse la instrucción de salto continue para pasar a la siguiente iteración saltando el resto de instrucciones en la iteración actual.
• Modificar la variable del bucle no modifica el elemento almacenado en el array. La variable declarada en la cabecera del for-each recibe un valor del array en cada iteración pero si se modifica esta variable no se modifica el valor del array. Por ejemplo, si numero es la variable y recibe el valor 1 desde el array, la asignación numero = 0 dentro de un for-each no cambia el valor del elemento del array. El elemento sigue valiendo 1.

Ejemplo1:

Programa que muestra el contenido de un array de números enteros.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle for-each
 * Mostrar el contenido de un array de enteros
 */
public class Ejemplo1ForEach {
    public static void main(String[] args) {
        int[] numeros = {3, -9, 2, 0, 4, -7};
        for (int n : numeros) {
            System.out.println(n);           
        }
        System.out.println("Fin programa");
    }
}

En este programa se muestra por pantalla el contenido del array numeros de tipo int.

Para mostrar el contenido del array se utiliza un bucle for-each que se ha escrito de esta forma:

for (int n : numeros) {

• int es el tipo del array que vamos a recorrer
• n es la variable donde se almacenará el valor de cada elemento del array en cada iteración del bucle
• numeros es el nombre del array que vamos a recorrer

En cada iteración del bucle la variable n recibe el valor del siguiente elemento del array. Dentro del bucle, la instrucción System.out.println(n); muestra ese valor por pantalla

El bucle termina cuando se han recorrido todos los elementos.

Salida por pantalla:

3
-9
2
0
4
-7
Fin programa

Ejemplo 2:

Mostrar el número de alumnos aprobados y suspendidos en una asignatura.

Disponemos de un array llamado notas de tipo double que contiene las notas de una serie de alumnos en una asignatura. El programa recorrerá este array y mostrará cuántos alumnos han aprobado y cuántos han suspendido la asignatura.

/*
 * Estructura repetitiva en Java
 * Ejemplo de bucle for-each
 * Mostrar el número de alumnos aprobados y suspendidos en una asignatura.
 */
public class Ejemplo2ForEach {
    public static void main(String[] args) {
        double[] notas = {6.75, 4.25, 8.5, 9.0, 5.6};
        int aprobados = 0, suspendidos = 0;
        for (double nota : notas) {
            if(nota >= 5){
                aprobados++;
            }else{
                suspendidos++;
            }
        }
        System.out.println("Aprobados: " + aprobados);
        System.out.println("Suspendidos: " + suspendidos);
        System.out.println("Fin programa");
    }
}

En este ejemplo la cabecera del bucle for-each para recorrer el array notas se ha escrito de esta forma:

for (double nota : notas) {

• double es el tipo del array que vamos a recorrer
• nota es la variable donde se almacenará el valor de cada elemento en cada iteración
• notas es el nombre del array que vamos a recorrer

En cada iteración la variable nota recibe un elemento del array notas.

Dentro del bucle se comprueba el valor de esa variable. Si es >= 5 se incrementa el contador del contador de aprobados. En caso contrario se incrementa el valor del contador de suspendidos.l

El bucle for-each finaliza cuando se ha procesado la última nota del array.

A continuación se muestra el número de aprobados y suspendidos por pantalla.

Salida por pantalla:

Aprobados: 4
Suspendidos: 1
Fin programa

Una instrucción de salto provoca la modificación del flujo de ejecución de un programa.

Las instrucciones de salto no son estructuras de control. Se utilizan para alterar el flujo de ejecución dentro de una estructura de control.

En Java, las principales instrucciones de salto son break, continue y return.

Las más relacionadas con la estructura repetitiva en Java son las instrucciones break y continue.

La instrucción return se utiliza para finalizar un método.

La instrucción break provoca la finalización de un bucle while, do-while, for o for-each sin esperar a que su condición deje de cumplirse. La ejecución del programa sigue por la siguiente instrucción después del bucle.

En aquellos casos en los que existan bucles anidados, un break produce la salida inmediata del bucle en el que se encuentra incluida pero no de los demás.

La instrucción break también se utiliza para finalizar las instrucciones switch.

Ejemplo:

Programa que muestra números desde 1 hasta 50 hasta que encuentre un número que sea múltiplo de 3 y de 5. Cuando encuentre el primer número que sea múltiplo de 3 y de 5 dejará de mostrar números y el programa finaliza.

/*
 * Estructuras repetitivas en Java
 * Ejemplo de instrucción break
 * Mostrar números hasta encontrar el primer múltiplo de 3 y de 5
 */
public class EjemploBreak {
    public static void main(String[] args) {
       for (int i = 1; i <= 50; i++) { //inicio del for
            if (i % 3 == 0 && i % 5 == 0) { //si es múltipo de 3 y de 5
                break;  // se provoca la finalización del for
            }
            System.out.println(i);
        } //fin del for
        System.out.println("Hasta Pronto!!!");
    }
}

En este ejemplo, cuando se ejecuta la instrucción break el bucle finaliza y la ejecución del programa continúa en la instrucción que aparece a continuación del for.

Muestra por pantalla:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Hasta Pronto!!!

La instrucción continue provoca la ejecución de la siguiente iteración en el bucle.

Cuando se ejecuta la instrucción continue se saltan las instrucciones que quedan hasta el final del bucle y se vuelve al inicio del mismo:

• Si se trata de un bucle for la ejecución continúa por la zona de incremento/decremento.
• Si es un bucle while o do .. while la ejecución del programa continúa por la evaluación de la condición.
• Si es un bucle for-each se pasa al siguiente elemento del array o de la colección.

A diferencia del break, continue no finaliza la ejecución del bucle.

Ejemplo:

Programa que muestra los números desde el 1 hasta el 50 excepto los que sean múltiplos de 3 y de 5.

/*
 * Estructuras repetitivas en Java
 * Ejemplo de instrucción continue
 * Mostrar los números del 1 al 50 excepto los múltiplos de 3 y de 5
 */
public class EjemploContinue {
    public static void main(String[] args) {
       for (int i = 1; i <= 50; i++) { //inicio del for
            if (i % 3 == 0 && i % 5 == 0) { // si es múltiplo de 3 y de 5
                continue; //siguiente iteración
            }
            System.out.println(i);
        } //fin del for
        System.out.println("Hasta Pronto!!!");
    }
}

Si la condición dentro del for se cumple se ejecuta la instrucción continue; La instrucción continue provoca un salto de forma que la ejecución continúa por la zona de incremento/decremento y se ejecute la instrucción i++.

La instrucción return provoca la finalización inmediata del método donde se encuentra.

Esta instrucción no está relacionada con la estructura repetitiva en Java. Aunque puede utilizarse dentro de una estructura repetitiva, su finalidad no es controlar la repetición del bucle. Cuando se ejecuta una instrucción return dentro de un bucle no solo finaliza el bucle, también finaliza el método que lo contiene.

A diferencia de break, que termina únicamente el bucle en el que se ejecuta, return finaliza el método completo y devuelve el control al punto desde el que fue llamado. Por eso se considera una instrucción de salto.

Por tanto, cuando se utiliza dentro de un bucle, deben tenerse en cuenta sus efectos sobre el conjunto del método, ya que las instrucciones que aparecen después de return no llegarán a ejecutarse si el flujo alcanza esa instrucción.

Ejemplo:

/*
 * Instrucciones de salto
 * Ejemplo de instrucción return
 */
public class EjemploReturn {
    public static void main(String[] args) {
        mostrarNumeros();
        System.out.println("Fin programa");
    }

    public static void mostrarNumeros() {
        for (int numero = 10; numero > 0; numero--) {
            if (numero == 5) {
                return;
            }
            System.out.println(numero);
        }
        System.out.println("Fin del método");
    }
}

En este ejemplo desde el método main se llama al método mostrarNumeros. Este método utiliza un bucle for para mostrar los números desde el 10 hacia abajo. En cada iteración se muestra el valor de la variable numero y se decrementa su valor en 1. Cuando la variable numero alcanza el valor 5 se ejecuta la instrucción return; que provoca que el método finalice. La instrucción System.out.println("Fin del método"); nunca llega a ejecutarse ya que después de return la ejecución del programa continúa en el punto donde se llamó al método, en este caso continúa por el método main y se ejecuta la instrucción System.out.println("Fin programa");.

Se muestra por pantalla:

10
9
8
7
6
Fin programa

Las instrucciones de salto ofrecen flexibilidad al programar, ya que permiten salir de un bucle sin tener que esperar a que la condición deje de ser cierta. Sin embargo, conviene utilizarlas con criterio y mantener un código fácil de comprender. Cuando una condición de salida puede expresarse claramente en la cabecera de un bucle, suele ser preferible hacerlo así, reservando los saltos para los casos en los que aporten claridad al algoritmo.

Lo recomendable es evitar su uso innecesario y utilizarlas solo cuando simplifique la lógica del bucle y facilite la lectura del código.

Aunque todas permiten repetir instrucciones, cada estructura repetitiva en java presenta características que la hacen más adecuada para determinadas situaciones.

El bucle while es adecuado cuando la repetición depende de una condición y no se conoce de antemano cuántas veces será necesario ejecutar el bloque de instrucciones. La condición se comprueba antes de cada iteración, por lo que el bucle puede no ejecutarse ninguna vez si la condición inicial es falsa.

Por ejemplo, resulta apropiado cuando se necesita solicitar datos hasta que el usuario introduzca un determinado valor o procesar información mientras se cumpla una determinada condición.

El bucle do .. while es especialmente útil cuando el bloque de instrucciones debe ejecutarse al menos una vez, independientemente de que la condición se cumpla o no inicialmente ya que la condición se comprueba después de ejecutar el bloque.

Un uso habitual es la implementación de menús interactivos que deben mostrarse al usuario al menos una vez y repetirse hasta que este elija la opción de salida. Otro uso habitual es la lectura de un dato por teclado comprobando que el dato introducido sea válido. La comprobación se hace una vez inrtoducido el dato.

El bucle for es la opción más apropiada cuando se conoce el número de iteraciones o cuando la repetición está controlada por una variable cuyo valor inicial, condición de continuación y actualización pueden expresarse claramente en la cabecera del bucle.

Por ejemplo, se utiliza habitualmente para introducir por teclado un número determinado de valores, realizar un proceso un número determinado de veces o recorrer el contenido de un array mediante un índice.

El bucle for-each está pensado para recorrer los elementos de un array o de una colección de objetos sin tener que gestionar explícitamente un índice. En cada iteración, la variable declarada en el bucle recibe uno de los elementos de la colección que se están recorriendo.

Es una opción especialmente recomendable cuando se necesita procesar todos los elementos de una colección y no es necesario conocer su posición ni controlar el recorrido mediante una condición específica.

Estas recomendaciones no son reglas estrictas. En muchos algoritmos es posible utilizar un while, un do .. while o un for para obtener el mismo resultado. En esos casos, conviene elegir la que exprese la intención del programa con mayor claridad.

La estructura repetitiva en Java es una de las tres que componen las estructuras de control en Java.

En estos temas se explican a fondo la estructura secuencial y condicional:

Enlace a la documentación oficial de Oracle sobre las estructuras de control en Java.