Recorrer arrays en Java con bucles

Leer array[0], array[1], array[2] a mano deja de escalar alrededor del elemento 3. Una vez que has creado un array, Java te ofrece varias formas de visitar cada elemento — elige la que se ajuste a lo que realmente necesitas hacer. Esta página cubre el for basado en índice, el for mejorado (for-each), los streams de arrays y cómo elegir entre ellos.

El bucle for clásico

El for basado en índice es la forma más flexible y es la única que te da la posición en la que te encuentras:

int[] scores = {90, 85, 73, 100, 62};
for (int i = 0; i < scores.length; i++) {
  System.out.println(i + ": " + scores[i]);
}

Úsalo cuando necesites:

• el índice (para imprimirlo, comparar elementos vecinos, saltar adelante)
• recorrer el array en sentido inverso — for (int i = scores.length - 1; i >= 0; i--)
• avanzar más de uno — i += 2
• mutar el array — asignando a scores[i]

El límite siempre es i < array.length, nunca un número fijo. Si el array cambia de tamaño más adelante (o se recibe desde otro lugar), el bucle sigue funcionando.

length es un campo, por lo que no lleva paréntesis: escribe scores.length, no scores.length(). (Los strings son diferentes — String tiene un método length().) Cuando el array está vacío, length es 0 y el cuerpo del bucle nunca se ejecuta, que es exactamente lo que quieres — no se necesita ninguna comprobación especial. Consulta el capítulo del bucle for para la mecánica general.

El for mejorado — "for-each"

Cuando todo lo que necesitas es el valor de cada elemento en orden, el for mejorado es más corto y claro:

int[] scores = {90, 85, 73, 100, 62};
int sum = 0;
for (int score : scores) {
  sum += score;
}
System.out.println("sum = " + sum);

Lee el dos puntos como "en": "para cada int score en scores." La variable del bucle es una copia nueva de cada elemento. No puedes obtener el índice de esta forma y no puedes modificar el array a través de score — asignar a score solo reasigna la variable local.

Usa el for mejorado para "hacer algo con cada valor." Usa el for clásico cuando el índice importa.

Lectura vs. escritura dentro de un bucle

Dentro de un for clásico, array[i] = newValue muta el array en su lugar:

int[] scores = {90, 85, 73, 100, 62};
for (int i = 0; i < scores.length; i++) {
  scores[i] = scores[i] + 5;     // give everyone a 5-point bonus
}

El for mejorado no puede hacer esto con tipos primitivos — score = score + 5 solo cambia la copia local:

for (int score : scores) {
  score = score + 5;             // no effect on scores
}

Para arrays de objetos, la variable del bucle sigue referenciando el mismo objeto que la posición en el array, por lo que llamar a métodos mutantes sobre ella sí cambia lo que ve el array. Pero reasignar la variable no lo hace.

Streams sobre arrays

Para arrays numéricos, el helper Arrays.stream(...) ofrece una API estilo pipeline:

import java.util.Arrays;

int[] scores = {90, 85, 73, 100, 62};
int total = Arrays.stream(scores).sum();
double avg  = Arrays.stream(scores).average().orElse(0);
int max     = Arrays.stream(scores).max().orElse(0);

Para arrays de objetos, Arrays.stream(...) devuelve un Stream<T> con los habituales métodos filter/map/reduce:

String[] names = {"Ada", "Linus", "Grace"};
long shortOnes = Arrays.stream(names).filter(n -> n.length() <= 3).count();

Los streams son expresivos pero no son gratuitos — para bucles internos muy ajustados, un for simple es más rápido y fácil de depurar. Recurre a los streams cuando la intención (sumar, filtrar-y-contar, agrupar, transformar) es lo que quieres hacer evidente. Consulta Java streams para la API de pipeline completa.

forEach desde el lado del array

No existe array.forEach(...). Los equivalentes más cercanos son Arrays.stream(arr).forEach(...) (numérico o de objetos) o, para arrays de objetos, el atajo Arrays.asList(arr).forEach(...). La mayoría de las veces el for simple o el for mejorado es suficiente — no recurras a forEach solo por probar una sintaxis diferente.

Elegir un bucle

Un ejemplo completo

Qué viene a continuación

Ahora puedes crear arrays y recorrerlos en todas las direcciones. Los datos del mundo real son a menudo bidimensionales — una cuadrícula, una tabla, un tablero — y Java lo admite con arrays multidimensionales, que son en realidad arrays de arrays.

Práctica