2 Bucles¶

Introducción¶

En programación, un bucle o instrucción de control repetitiva (o iterativa) permite ejecutar una o más instrucciones varias veces, es decir, permite ejecutar un bloque de instrucciones repetidamente, escribiéndolas una sola vez en el programa, reduciendo de este modo el código del mismo. Cada vuelta que da el bucle se conoce como iteración.

Las variables que se utilizan en los bucles pueden tener distintas funciones:

índice: es una variable que apunta a un recurso concreto. En los bucles, apunta al número de iteración. Se suelen utilizar por convenio los identificadores de variables i, j y k.
contador: cuenta cuántas veces ocurre algo.
acumulador: acumula operaciones parciales.

Las instrucciones básicas que permiten construir este tipo de estructuras son while, do-while y for.

Bucle while¶

El bucle while agrupa instrucciones las cuales se ejecutan continuamente mientras una condición que se evalúa sea verdadera. La condición se evalúa antes de entrar dentro del while y cada vez que se termina de ejecutar las instrucciones del while.

El programa se ejecuta siguiendo estos pasos:

Se evalúa la expresión lógica.
Si la expresión es verdadera ejecuta las instrucciones, sino el programa abandona la sentencia while.
Tras ejecutar las instrucciones, volvemos al paso 1.

EstructuraEjemplo

while(expresiónLógica){
    //instrucciones
}

import java.util.Random;

public class While1 {
    public static void main(String[] args) {
        int number;
        Random random = new Random();

        /*
         * Se obtiene un número aleatorio entre 1 y 500.
         * Mientras dicho número sea par, continuamos en el bucle while
         */
        while ((number = random.nextInt(500)+1) % 2 == 0){
            System.out.println(number);
        }
    }
}

Ejercicio 1

Dados dos números n1 y n2, tal que n1 <= n2, mostrar los números pares comprendidos entre ellos ambos incluidos. Visualizar al final el número total de pares encontrados. Hacer uso del bucle while.

Bucle do-while¶

La única diferencia respecto al while está en que la expresión lógica se evalúa después de haber ejecutado las instrucciones. Es decir, el bucle al menos se ejecuta una vez. Los pasos son los siguientes:

Ejecutar instrucciones.
Evaluar expresión lógica.
Si la expresión es verdadera, volver al paso 1. Si es falsa, salir del do-while.

Ejemplo que muestra números aleatorios entre 1 y 500 hasta que salga uno múltiplo de 7:

EstructuraEjemploEjemplo 2Ejemplo 3Ejemplo 4

do{
    // instrucciones
} while(expresiónLógica)

import java.util.Random;

public class DoWhile1 {
    public static void main(String[] args) {
        boolean exit = false;
        int number;
        Random random = new Random();

        do{
            number = random.nextInt(500) + 1; //(1)!
            System.out.println(number);
            exit = (number % 7 == 0); //(2)!
        } while (!exit); //(3)!
    }
}

Se calcula un número aleatorio entre 1 y 500
exit se pone a true si el número es múltiplo de 7
Condición de repetición: que exit sea false

Si le añadimos al ejemplo anterior que solamente haya 5 posibilidades para encontrar el múltiplo de 7, eso significa que necesitamos una variable que apunte al número de iteración del bucle para poder controlar que solamente se ejecute 5 veces, es decir, necesitamos un índice:

import java.util.Random;

public class DoWhile2 {
    public static void main(String[] args) {
        boolean exit = false;
        int number, i = 1; //(1)!
        Random random = new Random();

        do{
            number = random.nextInt(500) + 1;
            System.out.println(number);
            exit = (number % 7 == 0);
            i++;
        } while (!exit && i <= 5); //(2)!

        if(!exit){
            System.out.println("No se encontró el múltiplo de 7");
        }
    }
}

i es un índice porque apunta al número de iteración del bucle
Mientras exit sea false y además i sea menor o igual que 5

El bucle do-while se utiliza cuando se sabe que las instrucciones del bucle se van a ejecutar al menos una vez. En el bucle while puede ser que no se ejecuten nunca si la condición es falsa desde un principio. Las peticiones de usuario se realizan con bucles do-while, ya que la petición del dato al usuario siempre se realiza, y si el usuario no introduce lo que le hemos pedido, entonces utilizamos el bucle para volvérselo a pedir.

import java.util.Scanner;

public class DoWhile3 {
    public static void main(String[] args) {
        Scanner keyboard = new Scanner(System.in);
        int number;

        do{
            System.out.print("Introduzca un número del 1 al 5: ");
            number = keyboard.nextInt();
            System.out.printf("Has introducido un %d\n", number);
        }while (number < 1 || number > 5);
    }
}

import java.util.Scanner;

public class DoWhile4 {
    public static void main(String[] args) {
        Scanner keyboard = new Scanner(System.in);
        int number, counter = 0, sum = 0, index = 0;

        /*
         * index: es un índice porque apunta al número de iteración del bucle
         * counter: es un contador para contar el número de pares
         * sum: es un acumulador donde se acumula la suma de los números pares
         */
        do{
            System.out.print("Introduzca un número ó 0 para terminar: ");
            number = keyboard.nextInt();

            if(number != 0){
                index++; // Se incrementa el número de iteraciones del bucle
                System.out.printf("El número introducido en la iteración %d es %d\n", index, number);

                if(number % 2 == 0){ // si el número es par
                    counter++; // Se incrementa el contador
                    sum += number; // Se acumula la suma en el acumulador
                }
            }
        }while (number != 0);

        System.out.printf("En %d iteraciones se han introducido %d números pares cuya suma vale %d", index, counter, sum);
    }
}

Ejercicio 2

Dados dos números n1 y n2, tal que n1 <= n2, mostrar los números pares comprendidos entre ellos ambos incluidos. Visualizar al final el número total de pares encontrados. Hacer uso del bucle do-while.

Bucle for¶

El funcionamiento es el siguiente:

Se ejecuta la instrucción de inicialización.
Se comprueba la condición.
Si la condición es cierta, entonces se ejecutan las instrucciones. Si la condición es falsa, se abandona el bloque for.
Tras ejecutar las instrucciones, se ejecuta la instrucción de incremento y se vuelve al paso

EstructuraEjemploEjemplo con While

for(inicialización;condición;incremento){
    // instrucciones
}

Escribir números del 1 al 100:

public class For1 {
    public static void main(String[] args) {
        int i;

        for (i = 1; i <= 100; i ++){ //(1)!
            System.out.println(i);
        }
    }
}

i es un índice porque apunta al número de iteración del bucle

Los bucles for también se pueden hacer con while o do-while pero los for tienen una sintaxis más abreviada. Veamos el ejemplo For1 hecho con un while:

public class While2 {
    public static void main(String[] args) {
        int i = 1;

        while (i <= 100){
            System.out.println(i);
            i++;
        }
    }
}

Todos los bucles se pueden hacer con for, while y do-while, entonces, ¿cuál se debe usar? Es importante que le programador utilice la estructura más adecuada en cada caso:

Un bucle for se utiliza cuando se conozca el número de veces que se va a ejecutar el bucle, es decir, cuando se conozcan el número de iteraciones de antemano.
Si no se sabe de antemano el número de iteraciones, entonces hay que utilizar while o do-while
- Un bucle do-while se utiliza cuando las instrucciones del bucle se van a ejecutar al menos una vez.
- Un bucle while se utiliza, entonces, cuando las instrucciones del bucle pueden no ejecutarse nunca si la condición es falsa desde un principio.

También es posible declarar la variable dentro del propio bucle for, pero su ámbito de vida se reduce exclusivamente al bucle for, es decir, no se conoce fuera del for ya que muere en cuando el bucle se finalice.

public class For2 {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) { //(1)!
            System.out.println(i);
        }

        i = 1; //(2)!
    }
}

Se declara la variable i como int dentro del for
Error de compilación: i cannot be resolved to a variable

El bucle for también admite más de una variable, en cuyo caso, en las partes de inicialización e incremento, se utiliza como separador la coma ,:

public class For3 {
    public static void main(String[] args) {
        for(int i = 0, j = 10; i <= j; i++, j--){
            System.out.printf("i: %d j: %d\n", i, j);
        }
    }
}

CUIDADO

En los IDEs, se puede seleccionar variables líneas de códigos y se puede insertar fácilmente en un if o en un bucle.

Por motivos de legibilidad de código, es muy importante que las variables del for aparezcan en las 3 partes del for, es decir, en la inicialización, en la condición y en el incremento, ya que el programador que quiera saber cuántas iteraciones realiza el bucle, solamente con fijarse en la línea de código donde se encuentra el for, pueda saberlo. Si las variables del for no aparecen en las 3 partes, eso nos indica que es más conveniente realizar un while o un do-while.

Veamos el ejemplo que muestra números aleatorios entre 1 y 500 hasta que salga uno múltiplo de 7:

import java.util.Random;

public class For4 {
    public static void main(String[] args) {
        boolean exit = false;
        int number = 0, i;
        Random random = new Random();

        for(i = 1; !exit; i++){ // Este for no es legible, se debe sustituir por un do-while
            number = random.nextInt(500)+1;
            System.out.printf("Iteración %d, número: %d\n", i, number);
            exit = (number % 7 == 0);
        }

        System.out.printf("El múltiplo de 7 con valor %d se ha encontrado en la iteración %d", number, i - 1);
    }
}

Si le añadimos al ejemplo anterior que solamente haya 5 posibilidades para encontrar el múltiplo de 7:

import java.util.Random;

public class For5 {
    public static void main(String[] args) {
        boolean exit = false;
        int number = 0, i;
        Random random = new Random();

        /*
         * Ahora el for sí es legible porque la variable i aparece en las 3 partes:
         * en la inicialización, en la condición y en el incremento
         */
        for(i = 1; i <= 5 && !exit; i++){
            number = random.nextInt(500) + 1;
            System.out.printf("Iteración: %d, número: %d\n", i, number);
            exit = (number % 7 == 0);
        }

        if(exit){
            System.out.printf("El múltiplo de 7 con valor de %d se ha encontrado en la iteración %d", number, i - 1);
        } else {
            System.out.println("El múltiplo de 7 no se ha encontrado");
        }
    }
}

También es muy importante por motivos de legibilidad del código, que el único sitio donde se modifiquen los valores de las variables del for sea en la zona del incremento ya que el programador que quiera saber cuántas iteraciones realiza el bucle, solamente con ver la línea de código del for, pueda saberlo. Por ejemplo, este código no es adecuado ya que para salirse del bucle del for, se está modificando la variable i.

import java.util.Random;

public class For6 {
    public static void main(String[] args) {
        int number = 0, i;
        Random random = new Random();

        for(i = 1; i < = 5; i++){
            number = random.nextInt(500) + 1;
            System.out.printf("Iteración %d, número: %d\n", i, number);
            if(number % 7 == 0){
                i = 5; // No se pueden modificar las variables del for, solamente en el incremento
            }
        }

        if(number % 7 == 0){
            System.out.printf("El múltiplo de 7 encontrado vale %d", number);
        } else {
            System.out.println("El múltiplo de 7 no se ha encontrado");
        }
    }
}

Ejercicio 3

Dados dos números n1 y n2, tal que n1 <= n2, mostrar los números pares comprendidos entre ellos ambos incluidos. Visualizar al final el número total de pares encontrados. Hacer uso del bucle for.

Bucle for-each¶

Una de las cosas que incorporó Java 5 fue el bucle for-each. Esta estructura nos permite recorrer una colección o un array de elementos de una forma sencilla, evitando el uso de iteradores o de un bucle for normal.

También se usa el for-each para recorrer los valores de un enum. Para ello, se utiliza el método values() de los enum que está implícitamente declarado por el compilador:

EstructuraEjemplo

for(TipoVariable variable : values){
    //instrucciones
}

public class ForEachEnum {
    public enum DayOfWeek{
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }

    public static void main(String[] args) {
        for (DayOfWeek d : DayOfWeek.values()) {
            System.out.println(d);
        }
    }
}

Ejercicio 4

Crea un enum con los meses del año, y haciendo uso de un bucle for-each, muestra aquellos meses de verano.

Ejercicios¶

Ejercicio 5

Haz un programa para simular 20 lanzamientos de un dado.

Ejercicio 6

Genera 15 números aleatorios entre el rango de dos números solicitados al usuario.

Ejercicio 7

Dados dos números enteros positivos, calcula su producto utilizando solo sumas.

Ejercicio 8

Solicítale al usuario un número entre 0 y 10 ambos incluidos:

Si el usuario introduce un número que no esté dentro de ese rango, vuelve a pedírselo tantas veces como sea necesario, ese decir, hasta que introduzca un número entre 0 y 10.
Una vez obtenido el número dentro de ese rango, muestra la tabla de multiplicar de dicho número.

Ejercicio 9

Realiza un programa que solicite al usuario un número entero positivo n y dibuje un triángulo de asteriscos. El triángulo debe contener un asterisco en la primera línea, dos en la segunda, etc.; es decir, en la fila enésima deben aparecer n asteriscos. Ejemplo para n=5.

    *
   * *
  * * *
 * * * *
* * * * *

Ejercicio 10

Realiza un programa que solicite al usuario un número entero positivo n y dibuje un rombo de asteriscos. Por ejemplo, si n = 5 debería dibujarse:

    *
   * *
  * * *
 * * * *
* * * * *
 * * * *
  * * *
   * *
    *

Ejercicio 11

Realiza un programa que dibuje el triángulo hasta un valor dado. El triángulo contiene los números naturales correlativos, uno en la primera línea, dos en la segunda, etc,; es decir, en la fila enésima aparecen n valores. Ejemplo para n=5

        1
      1   2
    1   2   3
  1   2   3   4
1   2   3   4   5

Ejercicio 12

Realiza un programa que dibuje una pirámide de dígitos como la de la figura, pidiendo por teclado el número de filas de la misma. Ejemplo para n = 5:

            1
         1  2  1
      1  2  3  2  1
   1  2  3  4  3  2  1
1  2  3  4  5  4  3  2  1

Ejercicio 13

Crea un programa que dibuje un table de ajedrez.

Ejercicio 14

Solicítale al usuario una casilla de un tablero de ajedrez. Dibuja el tablero de ajedrez con el alfil colocado en dicha casilla y marca con un color diferente en el tablero las casillas a las que puede mover dicho alfil.

Ejercicio 15

Realiza un dibujo de una estrella de 6 puntas. Solicítale al usuario:

La altura de las puntas, como mínimo 2.
El color de la estrella: rojo o verde.

Ejercicio 16

Realiza un dibujo de un círculo rojo con fondo amarillo. Solicítale al usuario el número de líneas.

Ejemplo con 13 líneas

Ejemplo con 21 líneas: