Estructuras de Control: Repetitivas o de iteracción

Las estructuras de control de Repetitivas o de iteracción evalúan una condición al igual que las estructuras de control de selección pero ejecutan el mismo bloque código tantas veces como la condición siga siendo cierta, esto es lo que se llama "bucle" o "loop".

Como estas repeticiones se van a estar ejecutando mientas la evaluación sea verdadera es necesario agregar dentro de nuestro circuito un cambio para que no se nos vuelva infinito, es decir si "1<10" entramos al loop y en la segunda vuelta o iteración, nuestro "1<10" sigue siendo cierto, volvemos a caer dentro del loop y como no se vaya cambiando va a ocurrir que "1<10" se cumple siempre.

Por lo cual hay que tener siempre en cuenta la salida del bucle al momento de crearlo.

While

El bucle while evalua una condicion y de ser cierta ejecutará nuestro código. Una vez que llega al fin de nuestro bloque, vuelve a evaluar la condición, de encontrar verdadera la condición otra vez ejecutará nuestro código y volverá evaluar la condición una vez más hasta que sea falsa.

1. while(condicon){
2.     //nuestro código a repetir
3.     //Instruccion de cambio de variable
4. }
5. //código que continua luego que sale del bucle.

Veamos con un ejemplo, supongamos que deseamos conocer la tabla de multiplicar de algún número. Para lo cual utilizo estas 2 lineas de código para ingresar un entero por teclado:

• Scanner miScan = new Scanner(System.in);
• respuesta = miScan.nextInt();

También utilizo 3 variables de números enteros:

• respuestas: para el valor que yo ingreso por teclado(En la ejecución utilize el n°8)
• vuelta: quien me determina las vueltas del bucle, además es el número que recorre los enteros en 1 para multiplicar a mi respuesta
• resultado: el nombre lo dice, también es quién determina cuando salir del bucle al ser mayor a 10 veces mi respuesta

Entonces mi while repite cada linea de salida pero con valores incrementados hasta alcanzar el tope que yo le impongo, de 10 veces.

1. import java.util.Scanner;
2.  
3. public class Mientras {
4.     public static void main(String[]args){
5.         System.out.println("Ingrese un número de la tabla de multiplicación que desee conocer: ");
6.         int respuesta, vuelta = 1, resultado;
7.         Scanner miScan = new Scanner(System.in);
8.         respuesta = miScan.nextInt();
9.         resultado = respuesta;
10.         while(resultado < respuesta*10){
11.             resultado = respuesta * vuelta;
12.             System.out.println(respuesta + " * " + vuelta " = " + resultado );            
13.             vuelta++;
14.         }
15.     }
16. }

• run:
• Ingrese un número de la tabla de multiplicación que desee conocer:
• 8
• 8 * 1 = 8
• 8 * 2 = 16
• 8 * 3 = 24
• 8 * 4 = 32
• 8 * 5 = 40
• 8 * 6 = 48
• 8 * 7 = 56
• 8 * 8 = 64
• 8 * 9 = 72
• 8 * 10 = 80
• BUILD SUCCESSFUL (total time: 7 seconds)

Do/While

El problema que se me presenta con el "while" es que yo evaluo una condición primero para entrar al bucle, pero si la condición no es cierta la primera vez, entonces nunca entro al loop y me salto de este.

Para solucionar este inconveniente esta el do/while (hacer/mientras) que primero ejecuta mi bloque y luego evalua la condición , así me estoy asegurando de hacer la primera vuelta si o si.

El siguiente ejemplo lo tomo de nuestros amigos los simpsons, cuando bart y lisa querian ir al Montesplash y le preguntan a homero de "manera repetitiva" hasta encontrar la respuesta deseada, un String con el valor "si". Como homero no podia decir que si para que después le pregunten usamos el do-while

1. import java.util.Scanner;
2.  
3. public class Montesplash {
4.     public static void main(String[]args){
5.         String respuesta;
6.         String afirmativo = "si";
7.         do{
8.             System.out.println("¿Nos llevas a el Montesplash?");
9.             Scanner miScanner = new Scanner(System.in);
10.             respuesta = miScanner.nextLine();
11.         }while(!respuesta.equalsIgnoreCase(afirmativo));
12.         System.out.println("gracias!");
13.     }
14. }

For

El "for" no es mas que un "while" encubierto pero expresado de manera resumida en una sola línea de código

Supongamos que expresamos lo siguiente con un while:

Veremos que este cuenta con:

• Un punto de Partida: marcado con el entero "vuelta"
• Condición para finalizar marcado en la condición "vuelta <= 10"
• El incremento marcado con "vuelta++" dentro de nuestro código

Bueno, el ciclo "For" cuenta con estas 3 partes dentro de su condición separadas por ";" :

Generalmente se usa como variable entera a "i" de iterador en lugar de vuelta y este será menor a la condición para finalizar

Sigamos con los ejemplos de los Simpsons =) en todas las introoducciones bart es castigado a escribir en el pizarrón una y otra vez lo mismo. Si se tuviera que programar en java sería tan fácil como esto:

1. public class BartSimpson {
2.     public static void main(String[]args){
3.         for(int i = 0; i <= 20; i++){
4.             System.out.println(i " Yo no he visto a Elvis");
5.         }
6.     }
7. }

De esta forma con el loop for se repetiria 20 veces seguidas la misma frase como lo hemos determinado.

Continue y Break

La sentencia "break" del inglés "romper" viene a acabar con el bucle sin importar que éste halla llegado a su fin o no, cuando se ejecuta la linea del break, automaticamente se sale del loop.

Podemos nombrar un bucle para identificarlo con cualquier nombre seguido de : en la linea superior de este y decirle se interrumpa en algún momento.

1. int cien = 100;
2.  
3. esteEsMiBucle:
4. for(int i = 0; i < cien; i++){
5.     System.out.println(i);
6.     if(i == 5){
7.         break esteEsMiBucle;
8.     }
9. }

De esta manera, el loop está planteado para que se ejecute unas 100 veces mostrando un número que se incrementa, sin embrago al llegar a 5 se interrumpe el ciclo y se sale de este

Por su parte "continue" tiene un efecto parecido al break salvo que no ordena salirse del bucle pero si interrumpe todo lo que está debajo y continua con ejecuntandose las vueltas, es decir al llegar al continue nos obliga a detener la vuelta actual en ese punto y comenzar la siguiente

1. int diez = 10;
2.  
3. for(int i = 0; i < diez; i++){
4.     System.out.println(i);
5.     if(i == 5){
6.         continue;
7.         System.out.println("Esto no se muestra");
8.     }
9. }

La utilidad real del continue se da por ejemplo al cargar sistemáticamente un fichero, si en alguno ocurre un error por ejemplo en el n°15 le decimos que continue cargando los siguientes