4.3 Estructuras iterativas

4.3 Estructuras iterativas

Una estructura cíclica es la sentencia  de control que permite ejecutar  una o más instrucciones un número predeterminado de veces, mientras  o hasta que se cumpla una determinada condición. Las tres sentencias de repetición de Java son:

ü  Ciclos condicionados al inicio (while)

ü  Ciclos condicionados al final (do-while)

ü  Ciclos controlados por contador (for)

Repetir MIENTRAS (WHILE)

La sentencia while se utiliza en ciclos condicionados al inicio, es decir, aquellos en los que se evalúa una condición antes de entrar al ciclo y solo se entra a él en caso de que el resultado de la condición sea verdadero, manteniéndose dentro del ciclo mientras la condición se siga cumpliendo.

Formato general de la sentencia while:

while   (< expresión booleana> )

      < sentencias >;

Donde < expresión booleana > es cualquier condición simple o compleja cuyo valor  puede ser falso o verdadero, y < sentencias> puede ser una sentencia única  o una sentencia compuesta, lo cual obliga a utilizar llaves para delimitar el cuerpo o ámbito de la estructura cíclica.

 Ejemplo: Suponga que se quiere calcular la suma de los primeros 100 números enteros positivos 1, 2…..100. A continuación se muestra un fragmento del programa que permite realizar dicha suma utilizando una sentencia while:

int suma = 0,  numero = 1;

while ( numero  < =  100  )

{

     suma  =  suma   +  numero;

     numero  =  numero +  1;

 }

           

En el ejemplo anterior, se estarán acumulando (sumando) los valores de la variable numero mientras su valor sea menor o igual a 100, es decir, cuando numero sea igual a 101 el ciclo terminará porque la condición que se está probando será falsa.

Repetir hasta (do-while).

La sentencia do-while se condiciona al final del ciclo y por ello se ejecuta al menos una vez el bloque de instrucciones correspondientes al ciclo, manteniéndose ahí hasta que la condición evaluada sea falsa.

El formato general de la sentencia do-while es:

do

     < sentencias >;

while (  < expresión booleana > );

Ejemplo: Suponga que se desea hacer lo mismo que en el ejemplo anterior, el fragmento del programa quedaría de la siguiente manera.

int suma = 0, numero = 1;

do 

{

     suma += numero;

     numero + +;

}  while  ( numero < = 100 );

Es importante hacer notar que las sentencias que se encuentran en el cuerpo de una estructura do…while se podrían repetir desde 1 hasta n veces. Es decir, al menos se ejecutarán una vez, antes de que se evalúe la expresión booleana y se “decida” si se continúa dentro del ciclo o si termina su ejecución y pasa el control a la siguiente sentencia del programa.  En contraste, la estructura while presentada en la sección 7.1 permite la repetición de las sentencias que la componen desde 0 hasta n veces. Es decir, dado que lo primero que sucede es la evaluación de la expresión booleana, pudiera ocurrir que esta fuera falsa desde la primera vez, por lo que el ciclo nunca se efectuaría y se pasaría automáticamente el control a la siguiente sentencia que se encuentre en el programa, ignorando las sentencias escritas en el bloque del ciclo.

Ejemplo:

int x=5; while (x<5) {     System.out.println(x);     x++; }	int x=5; do {     System.out.println(x);     x++; } while (x<5);
En este ejemplo el ciclo nunca efectúa las instrucciones que contiene. No despliega el valor ni incrementa la variable.	En este ejemplo se mostraría en pantalla el número 5, se incrementa la variable x  y termina el ciclo.

Repetir desde (for).

La sentencia for es especialmente adecuada para ciclos controlados por contador. Aquí se emplea una variable numérica denominada variable de control(contador), cuya función es contar las veces que habrá de ejecutarse el ciclo, esta variable se inicializa con un valor e inmediatamente se evalúa la expresión booleana, si el resultado de la evaluación es verdadera, se ejecutan las sentencias del ciclo, en cualquier otro caso, la sentencia del for termina y el flujo de control se mueve a la sentencia que se encuentre inmediatamente después del ciclo for.  Cada vez que se ejecute el ciclo se incrementará automáticamente el valor de la variable de control y se evalúa de nuevo la expresión booleana, hasta terminar el ciclo cuando la condición sea falsa.

Formato general de la sentencia for :

   

     for ( < inicio >;  < expresión booleana >;  <incremento> )

             < sentencia >;

El componente < inicio > se emplea para inicializar la variable de control, también puede incluir la declaración de la misma, es decir se puede hacer algo como lo siguiente:

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

en lugar de:

int i;

for  (  i = 0; i < 10;  i + + )

Nota:

En el componente inicio la variable de control se puede inicializar con cualquier valor, aunque casi siempre suele ser 0 o 1.

El componente < expresión booleana > se refiere a la condición que habrá de cumplirse para poder entrar al ciclo y permanecer en el. Para el ejemplo anterior la expresión sería la siguiente:

 i< 10

El último componente es el del < incremento > que sirve para modificar el valor de la variable de control de tal modo que al cabo de algún tiempo no se cumpla la condición que mantiene la ejecución del ciclo provocando el final del mismo. En el ejemplo anterior se incrementa la variable de control en uno, pero se puede incrementar con valores distintos a uno, incluyendo valores negativos.

Ejemplo: Suponga que se desea hacer lo mismo que en los ejemplos anteriores, el fragmento del programa quedaría de la siguiente manera.

int  suma = 0, numero;

for  ( numero = 0;  numero<=100;  numero ++ )  

{

      suma + = numero;

}

Donde la variable de control en este ejemplo será la variable numero, que se inicializa con un valor de cero e inmediatamente después se evalúa la expresión booleana, que será verdadera mientras que numero tenga un valor menor o igual a 100 y saldrá del ciclo hasta que numero tome un valor de 101 en cuyo caso el resultado de la evaluación no se cumplirá, provocando con esto que la sentencia for termine su ejecución.

Ejercicio de autoestudio #1: Teclea lo siguiente en un programa de Java y escribe el resultado que observes en pantalla. Recuerda que cuando el ciclo ejecuta una sola línea (como en este ejemplo, que solo va ha ejecutar un c.println), las llaves que abren y cierran son opcionales. Cuando son más de una instrucción son obligatorias.

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

{

       System.out.println(i);

}

Observa que se declara e inicializa la variable i en 0 (cero), después se compara si su valor (el de i) es menor que 10, como el resultado de la condición es verdadera (true),  “entra” al cuerpo del ciclo a efectuar el c.println(i).  Después “regresa” e incrementa AUTOMÁTICAMENTE el valor de la variable en 1 (por eso dice i++ en el último componente del ciclo), vuelve a checar si la condición se cumple (es decir, si la variable sigue siendo menor que 10), y cada vez que esto sea cierto “entra” a realizar el c.println(i).  Continuando de esta manera hasta que la variable tome un valor de 10 (como 10 no es menor que 10 el ciclo termina).

Realice los siguientes cambios, ejecútelo nuevamente y analice el efecto  de cada uno de estos cambios en la ejecución del ejemplo. Después de cada ejecución déjelo nuevamente en su forma original para probar el siguiente cambio:

·         Cambie el valor final (10) por un valor de 20, ejecútelo nuevamente y analice lo que pasa.

·         Cambie el valor inicial (0) por un 5, ejecútelo nuevamente y analice lo que pasa.

·         Cambie el valor inicial (0) por un 5, ejecútelo nuevamente y analice lo que pasa.

·         Cambie el valor del incremento (i + +) por un incremento de (i + =2).

·         Cambie el valor del incremento (i + +) por un decremento de (i --).

Ejercicio de autoestudio #2: Teclea cada una de las siguientes sentencias y anota el resultado que aparece en pantalla para cada una:

for  (int i=1 ; i<=5 ; i++)          System.out.println(i+”    “);

for (int j=1; j<=20; j=j+2)       System.out.println(j + “    “);

for (int j=20; j>0; j=j-2)    System.out.println( j + “    “);

Ejercicio de autoestudio #3: Teclea cada una de las siguientes sentencias y estudia el resultado que aparece en pantalla para cada una:

double precio, total=0; for  (int i=1 ; i<=5 ; i++) {      System.out.println (”Da el precio del producto #“ + i  +”: ”);      precio=c.readDouble( );      total=total+precio; } System.out.println (“la suma de todos los precios es  ” + total); System.out.println (“el promedio de los precios es  ” + total/5);

int num, posi=0, neg=0;  for (int j=1; j<10; j=j+1) {     System.out.println (” Dame un número entero   diferente de cero: “);     num=c.readInt( );     if (num>0)          posi ++;     else          neg ++;  }  System.out.println (“Tecleaste  ” + posi   + ”  números positivos”);  System.out.println (“Tecleaste  ” +  neg  +  “  números negativos”);