El ciclo for repite una declaración o bloque de enunciados un número de veces
hasta que una condición se cumple.
Estos ciclos con frecuencia se usan para una iteración sencilla en
donde se repite un bloque de enunciados un cierto número de veces y después se
detiene, aunque también se los puede usar para cualquier clase de ciclo.
Formato:
for (inicialización; test; incremento) {
sentencias;
}
El inicio del ciclo for tiene tres partes:
·
Inicialización
es una expresión que inicializa el principio del ciclo. Si se tiene un índice,
esta expresión puede ser declarada e inicializada, int i = 0. Las variables que
se declaran en esta parte del ciclo son locales al ciclo: dejan de existir
después de acabar la ejecución del mismo.
·
Test
es la prueba que ocurre después de cada vuelta del ciclo. La prueba debe ser
una expresión booleana o una función que regresa un valor booleano, por
ejemplo, i < 10. Si la prueba es verdadera, el ciclo se ejecuta; cuando es
falsa, el ciclo detiene su ejecución.
·
Incremento
es una expresión o llamada de función. Por lo común, el incremento se utiliza
para cambiar el valor del índice del ciclo a fin de acercar el estado del ciclo
a false y que se complete.
Dentro del ciclo for existen sentencias que se ejecutan cada vez
que se itera el ciclo. Al igual que con if, se puede incluir un solo enunciado
o un bloque; en este último caso, como se sabe, se lo empieza y termina con
llaves ({ }).
Ejemplo: Ciclo for para inicializar todos los valores de un
arreglo String para cadenas vacías:
String strArray [ ] = new String[10];
int i; // índice del lazo
for (i = 0; i < strArray.length; i++)
strArray[i] = "";
Cualquier parte del ciclo for puede se un enunciado vacío, esto
es, puede incluir sólo un punto y coma sin ninguna expresión o declaración, y
esa parte del ciclo se ignorará.
También puede tenerse un enunciado vacío para el cuerpo del ciclo
for, si todo lo que se desea hacer se encuentra en la primera línea. Por
ejemplo, aquí está una que encuentra el primer número primo mayor que 4000:
for (i = 40001; notPrime(i); i +=2)
;
CICLOS
while y do
Estos ciclos permiten también a un bloque de código ejecutarse de
manera repetida hasta encontrar una condición específica. Utilizar uno de estos
tres ciclos es, por lo general, una cuestión de estilo de programación.
Los ciclos while y do son exactamente los mismos que en C y C++, a
excepción de que su condición de prueba debe ser un booleano.
CICLOS while
Se utilizan para repetir un enunciado o bloque de enunciados,
mientras una condición sea verdadera.
Formato:
while (condición) {
cuerpoDelLazo;
}
La condición es una expresión booleana. Si regresa true, el ciclo
while ejecuta los enunciados en cuerpoDelLazo y después prueba la condición
hasta que ésta sea falsa. También se puede emplear un enunciado sencillo en
lugar del bloque.
Ejemplo. Inicialización y escritura de un vector:
int [ ] A = new int[10];
for (int j = 0; j < A.length; j++)
A[ j ] = j + 2;
int i = 0;
while (i < A.length)
System.out.println("A[ " + i + " ] = " + A[i]);
Si la condición la primera vez que se prueba es falsa, el cuerpo
del ciclo while nunca se ejecutará.
Para este caso, cuando se desee que una iteración se ejecute por
lo menos una vez, se utiliza el ciclo do ... while, como se explica a
continuación.
CICLOS
do ... while
El ciclo do es como el ciclo while, excepto que ejecuta un
enunciado o bloque dado hasta que la condición es false.
La principal diferencia es que los ciclos while prueban la
condición antes de realizar el ciclo, lo cual hace posible que el cuerpo del
ciclo nunca se ejecute si la condición es falsa la primera vez que se prueba.
Los ciclos do ejecutan el cuerpo del ciclo por lo menos una vez
antes de probar la condición.
Formato:
do {
cuerpoDelLazo;
} while (condición);
•
cuerpoDelLazo se ejecuta por lo menos una vez.
•
La condición se prueba al final de la ejecución del cuerpo.
•
La condición es una prueba booleana: si regresa true, el ciclo se ejecuta otra
vez; si regresa false, se detiene.
Ejemplo:
int x = 1;
do {
System.out.println("Lazo, vuelta " + x);
x++;
} while (x <= 10);
SALIDA DE CICLOS
Todos los ciclos (for, while y do) se terminan cuando la condición
que prueba se cumple.
Para salir del ciclo de manera incondicional, se usan las palabras
clave break y continúe.
Ejemplo: copia de elementos de un arreglo de números enteros a un
arreglo de punto flotante hasta el final del arreglo o hasta que se encuentre
un 0.
int count = 0;
while (count < array1.length) {
if (array1[count] ==0) {
break;
}
array2[count] = (float) array1[count++];
}
El uso de continue es similar al de break, a excepción de que en
lugar de detener por completo la ejecución del ciclo, éste inicia otra vez la
siguiente iteración.
Para los ciclos do y while, esto significa que la ejecución del
bloque se inicia de nuevo.
Para los ciclos for, la expresión de incremento se evalúa y
después el bloque se ejecuta.
Usando el ejemplo anterior, se puede probar si el elemento actual
es 0 y reiniciar el ciclo si lo encuentra, para que el arreglo resultante nunca
contenga cero. Obsérvese que puesto que en el primer arreglo se saltan los
elementos, ahora se tiene que seguir a dos diferentes contadores de arreglos:
int count1 = 0;
int count2 = 0;
while (count1 < array1.length) {
if (array1[count1] ==0) {
count1++;
continue;
}
array2[count2++] = (float) array1[count1++];
}
CICLOS
ETIQUETADOS
Tanto break como continue pueden tener una etiqueta opcional que
le indique a Java dónde detenerse.
Sin una etiqueta, break saltará hacia el ciclo más cercano (a uno
envolvente o al siguiente enunciado fuera del ciclo) y continue reinicia el
ciclo envolvente.
Utilizar estas instrucciones etiquetadas, permite salirse de
ciclos anidados o continuar un ciclo fuera del actual.
Para utilizar un ciclo etiquetado, se agrega la etiqueta antes de
la parte inicial del mismo, con dos puntos entre ellos.
Después, cuando se utilice break o continue, se agrega el nombre
de la etiqueta, después de la palabra clave:
out:
for (int i = 0; i < 10; i++) {
while (x < 50) {
if (i * x == 400)
break out;
. . .
}
. . .
}
En este recorte de código, la etiqueta out marca el ciclo externo.
Entonces, dentro de los ciclos for y while, cuando una condición particular se
cumple, un break ocasiona que la ejecución se salga de ambos ciclos.
El siguiente programa contiene un ciclo anidado for. Dentro del
ciclo más profundo, si los valores sumados de los dos contadores es mayor que
cuatro, ambos ciclos se abandonan al mismo tiempo:
foo:
for (int i = 1, i <= 5; i++)
for (int j = 1; j <= 3; j++) {
System.out.println(" i es " + i + ", j es " +
j);
if (i + j) > 4)
break foo;
}
System.out.println("fin de lazos");
Salida del programa:
i es 1, j es 1
i es 1, j es 2
i es 1, j es 3
i es 2, j es 1
i es 2, j es 2
i es 2, j es 3
fin de lazos
Como se puede ver, el ciclo se iteró hasta que la suma de i y j
fue mayor que 4 y después ambos regresaron al bloque externo y el mensaje final
se imprimió.
No hay comentarios:
Publicar un comentario