Arrays y recorrido

Cinco notas podrían guardarse en cinco variables, pero pronto resultaría difícil aplicarles la misma operación. Un array agrupa una cantidad fija de valores del mismo tipo y permite acceder a cada uno por su posición.

Declarar y crear

int[] notas;
notas = new int[5];

El array tiene cinco posiciones y no podrá cambiar de tamaño. Los int comienzan con valor 0.

También podemos inicializar directamente:

int[] notas = {7, 9, 6, 8, 10};

Índices desde cero

valor:     7   9   6   8  10
índice:    0   1   2   3   4

System.out.println(notas[0]); // 7
System.out.println(notas[4]); // 10

La longitud se consulta con length, sin paréntesis:

System.out.println(notas.length); // 5

La última posición es notas.length - 1, no notas.length.

Leer y modificar

int[] puntos = {10, 20, 30};
puntos[1] = 25;
System.out.println(puntos[1]); // 25

El array mantiene su tamaño, pero sus elementos pueden cambiar.

Práctica inmediata

Crea un array con tres temperaturas, aumenta la segunda en un grado y muestra la primera y la última.

int[] temperaturas = {18, 20, 17};
temperaturas[1]++;
System.out.println(temperaturas[0]);
System.out.println(temperaturas[temperaturas.length - 1]);

Recorrer con for

Usamos índices cuando necesitamos la posición o queremos modificar elementos:

String[] tareas = {"Leer", "Practicar", "Revisar"};

for (int posicion = 0; posicion < tareas.length; posicion++) {
    System.out.println(posicion + ": " + tareas[posicion]);
}

La condición correcta es < tareas.length. Usar <= intentaría acceder a una posición inexistente al final.

Recorrer con foreach

Cuando solo necesitamos cada valor:

for (String tarea : tareas) {
    System.out.println(tarea);
}

Se lee: “para cada tarea de tareas”. No ofrece directamente el índice.

Asignar un valor a la variable del foreach no modifica la posición del array:

int[] valores = {1, 2, 3};

for (int valor : valores) {
    valor = valor * 2;
}

System.out.println(valores[0]); // sigue siendo 1

Para modificar posiciones, utiliza un for con índice.

Suma y promedio

double[] precios = {10.5, 8.0, 11.5};
double suma = 0;

for (double precio : precios) {
    suma += precio;
}

double promedio = suma / precios.length;
System.out.println(promedio); // 10.0

Antes de dividir, un programa general debería comprobar que la longitud no sea cero.

Máximo y mínimo

Si sabemos que hay al menos un elemento, usamos el primero como referencia:

int[] valores = {8, 3, 12, 5};
int maximo = valores[0];
int minimo = valores[0];

for (int valor : valores) {
    if (valor > maximo) {
        maximo = valor;
    }
    if (valor < minimo) {
        minimo = valor;
    }
}

System.out.println("Máximo: " + maximo);
System.out.println("Mínimo: " + minimo);

Empezar el máximo en 0 fallaría si todos los valores fueran negativos.

Buscar y contar

String[] nombres = {"Ana", "Luis", "Marta"};
String buscado = "Luis";
int posicionEncontrada = -1;

for (int posicion = 0; posicion < nombres.length; posicion++) {
    if (nombres[posicion].equals(buscado)) {
        posicionEncontrada = posicion;
        break;
    }
}

System.out.println(posicionEncontrada); // 1

-1 significa “no encontrado”. Guardamos la posición porque puede servir para consultar o actualizar ese elemento.

Para contar aprobados:

int[] notas = {7, 4, 6, 3, 9};
int aprobados = 0;

for (int nota : notas) {
    if (nota >= 5) {
        aprobados++;
    }
}

Arrays como parámetros

Un método puede recibir un array y devolver un dato calculado:

public static int sumar(int[] valores) {
    int suma = 0;
    for (int valor : valores) {
        suma += valor;
    }
    return suma;
}

int[] puntos = {4, 6, 10};
System.out.println(sumar(puntos)); // 20

El método recibe el array existente; no necesita conocer su longitud de antemano.

Programa completo: resumen de notas

public class ResumenNotas {
    public static void main(String[] args) {
        int[] notas = {7, 4, 9, 6, 8};

        System.out.println("Promedio: " + calcularPromedio(notas));
        System.out.println("Máxima: " + buscarMaximo(notas));
        System.out.println("Aprobados: " + contarAprobados(notas));
        System.out.println("Posición del 9: " + buscar(notas, 9));
    }

    public static double calcularPromedio(int[] valores) {
        int suma = 0;
        for (int valor : valores) {
            suma += valor;
        }
        return (double) suma / valores.length;
    }

    public static int buscarMaximo(int[] valores) {
        int maximo = valores[0];
        for (int valor : valores) {
            if (valor > maximo) {
                maximo = valor;
            }
        }
        return maximo;
    }

    public static int contarAprobados(int[] valores) {
        int cantidad = 0;
        for (int valor : valores) {
            if (valor >= 5) {
                cantidad++;
            }
        }
        return cantidad;
    }

    public static int buscar(int[] valores, int buscado) {
        for (int posicion = 0; posicion < valores.length; posicion++) {
            if (valores[posicion] == buscado) {
                return posicion;
            }
        }
        return -1;
    }
}

Cada método devuelve un dato simple. Para este ejemplo asumimos que el array no está vacío al calcular promedio y máximo.

Errores habituales

• Acceder a un índice negativo o igual a length.
• Escribir posicion <= array.length en el recorrido.
• Confundir length con el último índice.
• Intentar ampliar un array después de crearlo.
• Usar foreach cuando necesitamos modificar posiciones.
• Inicializar el máximo en un valor que puede ser mayor que todos los elementos.
• Calcular un promedio sin contemplar un array vacío.

Ejercicio: inventario fijo

Dados arrays paralelos de nombres y unidades, muestra los productos con menos de cinco unidades, calcula el total y actualiza un producto buscado.

Casos iniciales:

productos = Teclado, Ratón, Monitor
unidades  = 8, 3, 5
buscado   = Ratón
nueva cantidad = 6

Debe mostrar Ratón como stock bajo, total inicial 16 y actualizar su posición a 6.

Solución razonada

public class InventarioFijo {
    public static void main(String[] args) {
        String[] productos = {"Teclado", "Ratón", "Monitor"};
        int[] unidades = {8, 3, 5};

        int total = 0;
        for (int posicion = 0; posicion < unidades.length; posicion++) {
            total += unidades[posicion];
            if (unidades[posicion] < 5) {
                System.out.println("Stock bajo: " + productos[posicion]);
            }
        }
        System.out.println("Total inicial: " + total);

        String buscado = "Ratón";
        for (int posicion = 0; posicion < productos.length; posicion++) {
            if (productos[posicion].equals(buscado)) {
                unidades[posicion] = 6;
                System.out.println("Actualizado: " + productos[posicion]
                        + " = " + unidades[posicion]);
                break;
            }
        }
    }
}

Los mismos índices relacionan producto y cantidad. Es una solución apropiada para este nivel y un tamaño fijo. En la siguiente unidad organizaremos datos en filas y columnas mediante matrices.