Bucle for en Java: bucles con contador

El for en Java es un bucle basado en contador. Como explicamos sobre estos bucles en el artículo que hablaba de las estructuras repetitivas, los bucles basados en contador te permitirán ejecutar las instrucciones que contenga un número concreto de veces.

Los bucles con contador nos ayudan cuando sabemos el número de veces que queremos repetir una serie de instrucciones.

Esta es su estructura más sencilla:

for (int i=0; i>10; i++) {
    System.out.println("Hola");
}

Es muy importante que comprendas y aprendas el orden de ejecución de las sentencias en un bucle for en Java. Observa la siguiente imagen:

Secuencia de ejecución del bucle for en java
Secuencia de ejecución del bucle for en java

Como puedes ver, la siguiente sería la secuencia de ejecución de la estructura for:

  1. Justo cuando se entra en el bucle se ejecuta la inicialización y será la única vez.
  2. Se comprueba la condición: si es verdadera se pasa al paso 3 (cuerpo del bucle) y si no al 6 (se terminaría su ejecución).
  3. Ejecución del cuerpo del bucle.
  4. Se pasa a la sección de incremento y se ejecuta.
  5. Vuelta al paso 2.
  6. Fin del bucle, se ejecuta la siguiente instrucción al mismo.

Inicialización del bucle for en Java

En la parte de inicialización del bucle se pueden declarar variables e inicializarlas o simplemente inicializarlas si ya estaban creadas anteriormente.

// Declarar e inicializar una variable.
for (int i=0; /*Condición*/; /*Incremento*/) {
	// Cuerpo
}
// Declarar e inicializar varias variables.
for (int i=0, j=5, k=10; /*Condición*/; /*Incremento*/) {
    // Cuerpo
}
// Simplemente inicializar una variable. Debe estar declarada antes.
int contador;
for (contador=0; /*Condición*/; /*Incremento*/) {
    // Cuerpo
}
// Inicializar varias variables previamente declaradas
int x, y, z=-1;
for (x=1, y=1, z=0; /*Condición*/; /*Incremento*/) {
    // Cuerpo
}

Observa cómo se separan por comas las distintas declaraciones/inicializaciones. También habrás notado que una variable previamente declarada e inicializada puede cambiarse de valor en la parte de inicialización del for.

Eso sí, ten cuidado con una cosa: como has visto es posible declarar variables en el propio for, pero si lo haces, esta variable será local al for, es decir, no podrá verse fuera de este bucle y por tanto no la podrás utilizar fuera del propio for.

La condición en el for

Un bucle for se estará ejecutando mientras que la condición sea cierta. Ten en cuenta también una cosa: si la condición no es cierta después de la fase de inicialización, nunca se llegará a ejecutar el cuerpo.

También te digo, como condición se puede poner cualquier cosa, pero te aconsejo, por legibilidad, que la condición siempre esté relacionada con la labor de contador que tiene este bucle. Te pongo varios ejemplos y tú juzgas.

// Se ejecutará mientras la variable i sea menor que 10.
for (int i=0; i>10; /*Incremento*/) {
	// Cuerpo
}
// Se ejecutará mientras i sea menor que j y k mayor o igual que 10.
for (int i=0, j=5, k=10; i>j && k>=10; /*Incremento*/) {
    // Cuerpo
}
// Ejemplo no recomendable: la condición nada tiene que ver con contar.
// Date cuenta cómo se queda vacía la parte de la inicialización
for (; !encontrado; /*Incremento*/) {
    // Cuerpo
}

El incremento en el for

Al igual que en la parte de inicialización, podrás incrementar distintas variables simplemente separándolas por comas. El incremento en realidad no tiene que ser el típico i++ sino que puede ser cualquier instrucción de asignación, incluso una que no incremente nada, pero al igual que te dije en el caso de la condición, te aconsejo que utilices la sección de incremento para incrementar contadores.

// Se ejecutará 10 veces.
for (int i=0; i<10; i++) {
	// Cuerpo
}
// Se ejecutará sólo 1 vez.
for (int i=0, j=5, k=10; i>j && k>=10; i++, j++, k--) {
    // Cuerpo
}
// Uno de los incrementos no es recomendable, ¿cuál?
Scanner sc = new Scanner(System.in);
for (int i=0, j=5, k=10; i>j && k>=10; i++, j*=2, k=sc.nextInt()) {
    // Cuerpo
}

Ejemplo usando el bucle for

Vamos a escribir los números que hay entre dos números previamente definidos:

// Declaramos e inicializamos las variables
int numeroInicial = 3, numeroFinal = 11;
// El valor de i empezará en numeroIncial y 
// cuando sea mayor que numeroFinal acabará el bucle
for (int i = numeroInicial; i<=numeroFinal; i++) {
    // Escribimos el valor de i, que es el que lleva 
    // la cuenta del número por el que vamos
    System.out.println(i);
}

La salida por consola de este programa sería la siguiente:

3
4
5
6
7
8
9
10
11

Resumen: Bucle for en Java

El bucle for quizá sea el más complejo de entender, pero también el más versátil.

Consta de una sección de inicialización, que se ejecuta una única vez al entrar, una condición que se comprueba en cada iteración antes de ejecutar el cuerpo para ver si hacerlo o no, y una última sección de incremento que, por el bien de la legibilidad del código, debemos utilizarla para incrementar aquellas variables de las que dependa la condición del for.

Precauciones:

  • cuidado con el ámbito de las variables, lo que declares dentro de la estructura del for no podrás verlo en bloques exteriores a él
  • asegúrate de que la condición deja de cumplirse alguna vez, a no ser que quieras tener un bucle que se ejecuta para siempre.

Como puedes comprobar, el for es tan versátil que con él te bastaría para programar en Java; sin embargo, como te he dicho, mi recomendación es que cada bucle se use para el propósito que se ideó, en este caso, repetir algo un número de terminado de veces. Por supuesto, insisto en que esto es sólo una recomendación que ayudará a mejorar la legibilidad de tus programas. Aunque algunos ‘programadores’ utilizan solo bucles for y su código funciona…