3.3 ESTRUCTURA REPETITIVA O ITERATIVA EN JAVA

Esta estructura de control permite ejecutar de forma repetida una instrucción o un bloque de instrucciones.

Las instrucciones se repiten mientras que se cumpla una determinada condición.

Esta condición se conoce como condición de salida del bucle.

En Java las estructuras repetitivas se implementan mediante:

• ciclo while
• ciclo do .. while
• ciclo for

3.1 CICLO WHILE

Las instrucciones se repiten mientras la condición sea cierta.

En un ciclo while la condición se comprueba al principio del bucle por lo que las instrucciones que lo forman se ejecutan 0 ó más veces.

 

Representación en diagrama de flujo de un bucle do .. while:

 

 

 

 Sintaxis:

 

instrucción 1;

while (condición){ //inicio while

        instrucciones;

}  //fin while

instrucción 2;

 

 

 

 

 La ejecución de un bucle while sigue los siguientes pasos:

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

Ejemplo: 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.   

/*
 * Programa que lee números hasta que se lee un negativo y muestra la
 * suma de los números leídos 
 */
import java.util.*;
public class Ejemplo1While {
    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 ejemplo, según el enunciado, se trata de leer números enteros hasta que se introduzca un número negativo, por lo tanto, las instrucciones contenidas dentro del while se repiten mientras el número que introduzcamos sea >= 0.

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: programa que muestra N asteriscos por pantalla. El valor de N se introduce por teclado. 

/* 
 * programa que lee un número n y muestra n asteriscos
 */
import java.util.*;

public class Ejemplo2While {
    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("Fin programa");
    }
}

En este programa se trata de mostrar tantos asteriscos como indique el número N que se ha introducido por teclado.

Este es un ejemplo de estructura repetitiva en la que sabemos a priori cuántas veces se va a repetir el while. En este caso el while se va a repetir N veces. La variable contador será la variable de control que hará que el while termine. Cada vez que se muestra un asterisco por pantalla se suma 1 a esta variable. El while se repite mientras el valor del contador sea menor que el número total de asteriscos a mostrar.

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

Ejemplo: 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 ...).

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

public class Ejemplo3While {
    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
    }
}

Salida por pantalla:

 º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

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.

 

3.2 CICLO DO - WHILE

 

Las instrucciones se ejecutan mientras la condición sea cierta.

La condición se comprueba al final del bucle por lo que el bloque de instrucciones se ejecutarán al menos una vez.

Esta es la diferencia fundamental entre el bucle while y el bucle do .. while. Las instrucciones de un bucle while es posible que no se ejecuten si la condición inicialmente es falsa.

Diferencia entre un bucle while y un bucle do .. while:

• Bucle while se ejecuta 0 o más veces.
• Bucle do .. while se ejecuta 1 o más veces. 

Representación en diagrama de flujo de un bucle do .. while:

 

 Sintaxis do .. while:

instrucción1;
do{  //inicio do .. while
    instrucciones;
}while(condición);  //fin do .. while
instrucción2;

 

 

 

 

 

 

 

La ejecución de un bucle do - while sigue los siguientes pasos:

1. Se ejecutan las instrucciones a partir de la instrucción do{
2. Se evalúa la condición.
3. Si la condición no se cumple el programa sigue ejecutándose por la siguiente instrucción a continuación del  while.
4. Si la condición se cumple volvemos al paso 1.

Ejemplo: Programa que lee un número entero menor o igual que 100. Si el número es mayor que 100 se muestra un mensaje indicándolo y se vuelve a pedir. Finalmente se muestra por pantalla el número introducido.

//Programa que pide un número menor o igual que 100
import java.util.Scanner;
public class Ejemplo1DoWhile {
    public static void main(String[] args) {
        int valor;
        Scanner in = new Scanner( System.in );
        do {  //inicio del do .. while
            System.out.print("Introduce un número entero <= 100: ");                                              
            valor = in.nextInt();
            if(valor > 100){
                System.out.println("Número no válido");
            }
        }while (valor > 100);  //fin del do .. while
        System.out.println("Ha introducido: " + valor);                                                           
    }
}

Dos ejemplos de ejecución:

Introduce un número entero <= 100: 27   
Ha introducido: 27

Introduce un número entero <= 100: 690  
Número no válido
Introduce un número entero <= 100: 584  
Número no válido
Introduce un número entero <= 100: 58
Ha introducido: 58

En los ejemplos podemos comprobar que las instrucciones dentro del bucle do .. while se ejecutan al menos una vez.

Ejemplo: Programa que lee un número entero entre 1 y 10 ambos valores incluidos. Si el número es válido se muestra un mensaje indicándolo y se vuelve a pedir. Finalmente se muestra por pantalla el número introducido. 

// Programa que lee un número entre 1 y 10 
import java.util.Scanner;
public class Ejemplo2DoWhile {
    public static void main(String[] args) {
        int n;
        Scanner sc = new Scanner(System.in);
        do {  //inicio del do .. while
            System.out.print("Escribe un número entero entre 1 y 10: ");                                          
            n = sc.nextInt();
            if (n < 1 || n > 10) {
                System.out.println("Valor no válido");
            }
        } while (n < 1 || n > 10);   //fin del do .. while                                                        

        System.out.println("Ha introducido: " + n);
    }
}

Dos ejemplos de ejecución del programa:

Escribe un número entero entre 1 y 10: 3  
Ha introducido: 3

Escribe un número entero entre 1 y 10: -2  
Valor no válido
Escribe un número entero entre 1 y 10: 6
Ha introducido: 6

Ejemplo: Programa que muestra los números del 1 al 10 todos en la misma fila y separados por un espacio en blanco.

import java.util.Scanner;
public class Ejemplo3DoWhile {
    public static void main(String[] args) {                                                                      
        int i = 1;
        do {   //inicio del do .. while
            System.out.print(i + " ");
            i++;
        } while (i<=10);   //fin del do .. while                                                                  
        System.out.println("\nFin programa");
    }
}

El programa muestra por pantalla:

1 2 3 4 5 6 7 8 9 10   
Fin programa

En este caso la variable i es la que contienen los valores a mostrar por pantalla. También es la variable de control que determina cuando finaliza el bucle. Inicialmente vale 1 y en cada iteración, después de mostrar su valor por pantalla se incrementa. El do .. while se repite mientras el valor de i sea menor o igual a 10.

 

3.3 CICLO FOR

Un for hace que una instrucción o bloque de instrucciones se repitan un número determinado de veces mientras se cumpla la 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.

Representación en diagrama de flujo de una instrucción for:

Sintaxis Java del bucle for:

instrucción1;

for(inicialización; condición; incremento/decremento){ //inicio for

     instrucciones;

}  //fin for

instrucción2;

A continuación de la palabra for y entre paréntesis debe haber siempre tres zonas separadas por punto y coma:

• zona de inicialización.
• zona de condición
• zona de incremento ó decremento. 

 

Las tres zonas 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.

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 es 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.

La ejecución de un bucle for sigue los siguientes pasos:

1. Se inicializa la variable o variables de control (zona de inicialización)
2. Se evalúa la condición (zona de 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 actualiza la variable o variables de control (zona incremento/decremento)
6. Se vuelve al punto 2.

Igual que el bucle while, un bucle for se puede ejecutar 0 ó más veces.

Ejemplo: Programa que muestra los números del 1 al 10 ambos incluidos todos en la misma línea y separados por un espacio en blanco.  

/*
 * programa que muestra los números del 1 al 10                                                                   
 */
public class Ejemplo1For {
    public static void main(String[] args) {
        int i;
        for (i = 1; i <= 10; i++) {    //inicio del for
            System.out.print(i + " ");
        }  //fin del for
        System.out.println("\nFin programa");                                                                     
    }
}

Salida por pantalla:

1 2 3 4 5 6 7 8 9 10   
Fin programa

La instrucción for del ejemplo la podemos interpretar de esta forma:

Primero asigna a i el valor inicial 1 y a continuación se comprueba la condición. Mientras que i sea menor o igual a 10 muestra i + " ", a continuación incrementa el valor de i y se comprueba de nuevo la condición. El for se repite mientras i sea <= 10.

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 incialización. Si lo hacemos de esa forma el programa quedaría así:

// Programa que muestra los números del 1 al 10
public class Ejemplo1For {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {    //inicio del for                                                       
            System.out.print(i + " ");
        }  //fin del for
        System.out.println("\nFin programa");                                                                     
    }
}

Ejemplo: Programa que muestra los números del 10 al 1 ambos incluidos todos en la misma línea y separados por un espacio en blanco.

// Programa que muestra los números del 10 al 1
public class Ejemplo2For {
    public static void main(String[] args) {
        for (int i = 10; i > 0; i--) {    //inicio del for                                                        
            System.out.print(i + " ");
        }  //fin del for
        System.out.println("\nFin programa");                                                                     
    }
}

Salida por pantalla:

10 9 8 7 6 5 4 3 2 1   
Fin programa

La instrucción for del ejemplo la podemos interpretar así:

Primero asigna a i el valor inicial 10 y a continuación se comprueba la condición. Mientras que i sea mayor que 0 muestra i + " ", a continuación se decrementa el valor de i y se comprueba de nuevo la condición. El for se repite mientras i sea > 0.

Ejemplo: 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 anterior, 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 ...).

//Programa que muestra una tabla de equivalencias entre grados Fahrenheit y celsius
public class Ejemplo3For {
    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);
        }
    }
}

Salida por pantalla:

 º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 del ejemplo la podemos interpretar así:

Primero asigna a fahrenheit el valor inicial 10 y a continuación se comprueba la condición. Mientras que  fahrenheit sea menor o igual que 100 se ejecutan las instrucciones del for, a continuación se incrementa el valor de  fahrenheit en 10 y se comprueba de nuevo la condición. El for se repite mientras fahrenheit sea <= 100.

Ejemplo: Dadas dos variables enteras a y b con valor inicial 1, escribimos un programa que muestre una tabla con el valor de ambas variables y su suma. En cada iteración el valor de a se incrementa en 1 unidad y el valor de b se incrementa en 2 unidades. La tabla finaliza cuando la suma de a y b sea >= 10.

Este es un ejemplo de programa que utiliza varias variables en las zonas de inicialización e incremento/decremento. 

// Programa que muestra el valor de a, b y su suma mientras que la suma sea menor de 10. 
// En cada iteración el valor de a se incrementa en 1 unidad y el de b en 2
public class Ejemplo4For {
    public static void main(String[] args) {                                                                      
        for(int a = 1, b = 1; a + b < 10; a++, b+=2){
            System.out.println("a = " + a + "  b = " + b + "  a + b = " + (a+b));                                 
        }
    }
}

La salida de este programa es: 

a = 1  b = 1  a + b = 2   
a = 2  b = 3  a + b = 5
a = 3  b = 5  a + b = 8

La instrucción for del ejemplo la podemos interpretar así: Primero asigna a las variables a y b el valor 1 y a continuación se comprueba la condición. Mientras que la suma de a + b sea menor que 10 se ejecuta las instrucción del for, a continuación se suma 1 a la variable a y se suma 2 a la variable b y se comprueba de nuevo la condición. El for se repite mientras que la suma a +b sea menor que 10.

 

Un error que se puede cometer cuando escribimos un for es escribir el punto y coma después del paréntesis final. Un bucle for generalmente nunca lleva punto y coma final. 

Por ejemplo el bucle:

for (int i = 1; i <= 10; i++);

{

     System.out.println("Elementos de Programación");

}

no visualiza la frase "Elementos de Programación" 10 veces como cabría esperar, ni produce un mensaje de error por parte del compilador.

En realidad lo que sucede es que se visualiza una vez la frase "Elementos de Programación", ya que aquí la sentencia for es una sentencia vacía, sin instrucciones a realizar, al terminar con un punto y coma (;).

El for en este caso se limita a realizar la asignación inicial de la variable, y mientras se cumpla la condición incrementar el valor de i. La variable i toma como valor incial 1 y cuando el for termina valdrá 11. A continuación se mostrará el mensaje por pantalla.

 

¿Que estructura repetitiva usar?

Aunque un for se puede utilizar también cuando no se sabe a priori el número de iteraciones a realizar, esta instrucción es especialmente indicada para bucles donde se conozca el número de pasadas.

Como regla práctica podemos decir que:

• La instrucción for se utiliza generalmente cuando se conoce el número de iteraciones a realizar.
• Las instrucciones while y do-while se utilizan generalmente cuando no se conoce a priori el número de iteraciones a realizar.
• La instrucción do .. while será más adecuada que la instrucción while cuando el bloque de instrucciones se deban repetir al menos una vez.

3.4 BUCLES ANIDADOS

Hablamos de bucles anidados cuando se incluyen instrucciones for, while o do-while unas dentro de otras. Los anidamientos de estas estructuras tienen que ser correctos, es decir, una estructura anidada dentro de otra lo debe estar totalmente, sin solaparse una con la otra.

Sintaxis para anidar dos bucles for:

for(inicialización; condición; incremento/decremento){ //inicio del for1                                          
     instrucciones1;
     for(inicialización; condición; incremento/decremento){ //inicio for2
         instrucciones2;   //instrucciones que se ejecutan en for2                                                
     }  //fin del for2
     instrucciones3;
}  //fin del for1

Sintaxis para anidar dos bucles while:

while(condición){   //inicio del while 1
      instrucciones1;
      while(condición){   //inicio del while 2                                                                    
            instrucciones2;
      }   //fin del while 2                                                                                       
      instrucciones3;
}

Sintaxis para anidar dos bucles do .. while:

do{  //inicio del do .. while 1
   instrucciones1;
   do{   //inicio del do .. while 2                                                                               
      instrucciones2;
   }while(condición);  //fin del do .. while 2                                                                    
   instrucciones3;     
}while(condición);   // fin del do .. while 1

Los bucles se pueden anidar aunque sean de tipos distintos, por ejemplo podríamos anidar un bucle for dentro de un do .. while y éste a su vez dentro de un while de esta forma: 

while(condición){   //inicio del while
      instrucciones1;
      do{  //inicio del do .. while
         instrucciones2;
         for(inicialización; condición; incremento/decremento){ //inicio del for                                  
             instrucciones3;
         }  //fin del for
         instrucciones4;
      }while(condición);  //fin del do .. while                                                                   
      instrucciones5;
}  //fin del while

Ejemplo: programa que dibuja un rectángulo formado por asteriscos. El número de filas y columnas del rectángulo se pide por teclado. El número de filas y de columnas debe ser > 1.

// Rectángulo sólido de asteriscos.
import java.util.Scanner;
public class Ejemplo1BuclesAnidados {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int filas, columnas;
        //leer número de filas hasta que sea un número > 1                                                        
        do{
           System.out.print("Introduce número de filas: ");
           filas = sc.nextInt();
        }while(filas < 2);
        //leer número de columnas hasta que sea un número > 1
        do{
           System.out.print("Introduce número de columnas: ");
           columnas = sc.nextInt();
        }while(columnas < 2);
        for(int i = 1; i <= filas; i++){    //for para las filas
            for(int j = 1; j <= columnas; j++){   //for para las columnas                                           
                System.out.print(" * ");
            }  //fin del for para las columnas
            System.out.println();
        }  //fin del for para las filas 
    }
}

Ejemplo de ejecución:

Introduce número de filas: 6
Introduce número de columnas: 10     
 *  *  *  *  *  *  *  *  *  * 
 *  *  *  *  *  *  *  *  *  * 
 *  *  *  *  *  *  *  *  *  *        
 *  *  *  *  *  *  *  *  *  * 
 *  *  *  *  *  *  *  *  *  * 
 *  *  *  *  *  *  *  *  *  *

En este programa se han anidado dos bucles for para mostrar el rectángulo de asteriscos.

El bucle for externo es el que corresponde a las filas. El for interno corresponde a las columnas.

Para cada una de las filas se ejecuta completamente el for de las columnas con lo que se consigue que para cada fila se muestren tantos asteriscos como columnas haya.

Al final de cada fila se escribe un salto de línea para que la siguiente fila comience a mostrarse en la línea siguiente.

Ejemplo: programa que dibuja un cuadrado formado por dígitos del 0 al 9. El número de filas del cuadrado se pide por teclado. El número de filas debe ser > 1.

import java.util.Scanner;
public class Ejemplo2BuclesAnidados {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int filas, columnas, contador = 0;
        //leer número de filas del cuadrado
        do{
           System.out.print("Introduce número de filas del cuadrado: ");                                          
           filas = sc.nextInt();
        }while(filas<2);
        for(int i = 1; i<=filas; i++){    //filas
            for(int j = 1; j<=filas; j++){   //columnas = filas                                                   
                 System.out.print(contador % 10 + " ");
                 contador++;
            } //fin del for para las columnas
            System.out.println();
        } //fin del for para las filas  
    }
}

Ejemplo de ejecución:  

Introduce número de filas del cuadrado: 6   
0 1 2 3 4 5 
6 7 8 9 0 1 
2 3 4 5 6 7 
8 9 0 1 2 3 
4 5 6 7 8 9 
0 1 2 3 4 5

Ejemplo: A partir de una variable x que tomará los valores desde 1 hasta 10, mostrar una tabla de potencias de x. Para cada valor de x se mostrará   x²    x³     x⁴

/* 
 * Programa que muestra una tabla con las potencias de x (x x2 x3 x4)
 * para valores de x desde 1 hasta 10
 */
import java.util.Scanner;
public class Ejemplo1BuclesAnidados3{
    public static void main(String[] args) {
        int x, n;
        //mostrar la cabecera de la tabla
        System.out.printf("%10s%10s%10s%10s%n", "x", "x^2", "x^3", "x^4");                                        
        for (x = 1; x <= 10; x++) {   //filas
            for (n = 1; n <= 4; n++) {   //columnas
                System.out.printf("%10.0f", Math.pow(x, n));                                                      
            }  //fin del for para las columnas
            System.out.println();
        } //fin del for para las filas
    }
}

La salida de este programa es:

         x       x^2       x^3       x^4   
         1         1         1         1
         2         4         8        16
         3         9        27        81
         4        16        64       256
         5        25       125       625
         6        36       216      1296
         7        49       343      2401
         8        64       512      4096
         9        81       729      6561
        10       100      1000     10000 

4. INSTRUCCIONES DE SALTO

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

Java ofrece dos instrucciones de salto:

• break
• continue

4.1 BREAK

Esta instrucción provoca la finalización de una instrucción switch, while, do-while o for. En aquellos casos en los que existan estructuras de control repetitivas anidadas, un break produce la salida inmediata de aquel bucle en el que se encuentre incluida pero no de los demás.

La única situación en la que un buen programador debería utilizar la instrucción break, es para separar los diferentes casos de una instrucción switch.

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

public class Ejemplo1Break {
    public static void main(String[] args) {
           for (int i = 1; i <= 50; i++) {  //inicio del for                                                       
                if (i % 3 == 0 && i % 5 == 0) {
                    break;     //provoca el final 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 for finaliza y la ejecución del programa continúa en la instrucción que aparece a continuación del for.

4.2 CONTINUE

Esta instrucción provoca la ejecución de la siguiente iteración en el bucle, es decir, se salta las instrucciones que quedan hasta el final del bucle, y vuelve al inicio del mismo. Si se trata de un bucle for vuelve a la zona de incremento/decremento.

Un buen programador deberá evitar el uso de esta instrucción.

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

public class Ejemplo1Continue {
    public static void main(String[] args) {
        for (int i = 1; i <= 50; i++) {   //inicio del for                                                        
            if (i % 3 == 0 && i % 5 == 0) {
                continue; //siguiente iteracicón del for                                                          
            }
            System.out.println(i);
        }  //fin del for
    }
}