Algoritmos de arrays útiles¶

Un array que utiliza un solo índice para acceder a sus valores se denomina array unidimensional, ya que utilizamos el índice para acceder a todas las celdas del array. Éstas celdas están alineadas de forma secuencial.

Un array bidimensional necesita dos índices para acceder a los valores. En este caso las celdas están dispuestas en forma de matriz, como una estructura rectangular.

Es posible crear arrays de mayores dimensiones aunque rara vez se utilizan.

Tamaño del array: length¶

Todo objeto de tipo array tiene una propiedad llamada length que contiene el tamaño del array, es decir, el número de elementos.

int[] numeros = {10, 20, 30, 40};
System.out.println(numeros.length);//4

Imprimir los elementos de un array¶

Un algoritmo muy utilizado cuando trabajamos con arrays es mostrar los valores que contiene el array en cada una de sus celdas. Para ello nos ayudamos del campo length que nos devuelve la longitud del array.

public static void imprimirArray(int[] array) {
    for(int i = 0; i < array.length; i++) {
        System.out.println("Elemento " + i + " valor " + array[i]);
    }
}

Leer y rellenar los elementos de un array por teclado¶

Es muy común que los elementos de un array sean valores introducidos de alguna forma por el usuario. El ejemplo más sencillo es leerlos directamente desde la entrada de flujo, a la vez que leemos el valor insertado por el usuario se lo asignamos al array.

    int[] array = new int[elementos];

    for (int i = 0; i < array.length; i++) {
        array[i] = sc.nextInt();
    }

Clásico error 1: no testear los límites del array¶

Cuando trabajamos con arrays, a menudo nos puede ocurrir que olvidamos el último elemento del array, si cambiamos la condición del bucle por i < array.length -1, o olvidamos el primer elemento si establecemos el índice en int i = 1 porque creemos que el primer elemento está en la posición 1 del array.

Estos son errores clásicos: no probar los límites de los arrays, es decir, el primer elemento o el último.

Por ejemplo, en el siguiente código no quiero tener números de una cifra en mi array.

    int[] datos =  {2, 19, 1, 5, 1, 27, 9, 5};

    for (int i = 0; i < datos.length-1; i++) {
        if (datos[i] < 10)
            datos[i] = datos[i] * 10;
    }

Cuando recorro el array, el último elemento no sería testeado por tanto me devolvería un 5 en vez de 50. El programa sería incorrecto.

Arrays

Clásico error 2: exceder los límites del array¶

Al contrario que, en el apartado anterior, si intentamos acceder a una celda del array que no existe, se lanzará una ArrayIndexOutOfBoundsException y el programa se detendrá.

Los errores de acceso a la última posición del array + 1 son muy comunes. Un ejemplo sería:

    int[] datos =  {2, 19, 1, 5, 1, 27, 9, 5};

    for (int i = 0; i <= datos.length; i++) {
        if (datos[i] < 10)
            datos[i] = datos[i] * 10;
    }

Bucle foreach (enhanced for loop)¶

Para evitar que los errores mencionados anteriormente ocurran, Java dispone de un bucle mejorado que visita cada elemento del array en orden sin necesidad de establecer un índice. Por tanto, los errores de exceder los límites del array se eliminan automáticamente con este bucle.

La sintaxis es la siguiente:

POO

Este bucle se lee de la siguiente manera: "para cada valor del array..." (for each value in array...)

El tipo de dato de la variable que se crea en el bucle es igual al de cada una de las celdas del array, y va a contener los valores de ellas. En la primera iteración contrendrá el valor de la primera celda del array, y así sucesivamente hasta llegar a la última celda del array.

Ejemplo:

    int[] array =  {2, 19, 1, 5, 1, 27, 9, 5};
    int suma = 0;
    for (int numero : array) {
            suma += numero;
    }

Comparar si dos arrays son iguales¶

Es muy usual utilizar el operador "==" cuando queremos comparar si dos arrays son iguales, es decir, si contienen los mismos elementos. Pero si ejecutamos el siguiente código:

    int[] array1 =  {1, 2, 3};
    int[] array2 =  {1, 2, 3};

    System.out.println(array1 == array2); //imprime false

Obtenemos false, esta situación es parecida a cuando intentábamos comparar dos String. Recordar que utilizar el operador "==" era incorrecto ya que son objetos diferentes aunque tuvieran el mismo contenido.

Si utilizamos el método equals() para arrays, devolvería el mismo valor booleano que el operador "==".

    System.out.println(array1.equals(array2)); //imprime false

Para comprobar que dos arrays contienen los mismos elementos se utiliza la clase Arrays.

La clase Arrays contiene muchos métodos estáticos para manipular matrices. Dado que los métodos son estáticos, los invoca utilizando el nombre de la clase.

    int[] array1 =  {1, 2, 3};
    int[] array2 =  {1, 2, 3};

    System.out.println(Arrays.equals(array1, array2)); //imprime true

El método Arrays.equals comprueba que dos arrays son iguales si tienen la misma longitud y contienen los mismos elementos en el mismo orden.

Otros métodos de Array¶

Array-Api de java

Método	Descripción	Ejemplo de Uso
static void fill(T[] array, T valor)	Llena el array con el valor indicado: todos los elementos iguales.	`int[] arr = new int[5]; Arrays.fill(arr, 10);`
static boolean equals(T[] a1, T[] a2)	Chequea si los arrays son idénticos, comprobando valores primitivos (==) y referencias (con equals).	`boolean iguales = Arrays.equals(a, b);`
static boolean deepEquals(Object[] a1, Object[] a2)	Chequea si los arrays son idénticos, comprobando valores primitivos (==) y referencias (con equals). Además, si el array es multidimensional, profundiza en las sucesivas dimensiones.	`Object[][] m1, m2; boolean iguales = Arrays.deepEquals(m1, m2);`
static String toString(T[] datos)	Genera una cadena para impresión (ej: [1, 2, 3]).	`String s = Arrays.toString(datos);`
static String deepToString(T[] datos)	Genera una cadena para impresión, incluso si se trata de un array multidimensional (ej: [[1, 2], [3, 4]]).	`String s = Arrays.deepToString(matriz);`
static T[] copyOf(T[] datos, int n)	Genera una copia de los datos. Si n es mayor que datos.length, rellena con null. Si n es menor que datos.length, se ignora el exceso (es decir, trunca).	`int[] copia = Arrays.copyOf(original, 8);`
static T[] copyOfRange(T[] datos, int desde, int hasta)	Copia un segmento de los datos (el rango incluye desde pero excluye hasta).	`int[] segmento = Arrays.copyOfRange(datos, 2, 5);`
static int binarySearch(T[] datos, T clave)	Busca en qué posición del array datos se encuentra la clave dada. El array debe estar ordenado.	`int indice = Arrays.binarySearch(datos, clave);`
static void sort(T[] datos)	Ordena el array de forma ascendente.	`Arrays.sort(datos);`
static void sort(T[] datos, int desde, int hasta)	Ordena el array entre las posiciones indicadas (rango incluye desde pero excluye hasta).	`Arrays.sort(datos, 0, 5);`

Caso práctico real uso de un array¶

Vamos a presentar un ejemplo de un caso real para el que los arrays son muy efectivos. Por ejemplo pedir al usuario que inserte números y mostrar la media de los números insertados.

import java.util.Scanner;

/**
 * Clase Notas: permite leer las notas de un grupo de alumnos,
 * almacenarlas, imprimirlas y calcular su media.
 */
public class Notas {

    /** Array que almacena las notas de los alumnos */
    private int[] notas;

    /** Scanner para leer datos desde teclado */
    private Scanner sc;

    /**
     * Constructor por defecto que inicializa el Scanner.
     */
    public Notas() {
        sc = new Scanner(System.in);
    }

    /**
     * Lee las notas de los alumnos y las guarda en el atributo notas.
     * Si el número de alumnos es incorrecto, deja notas = null.
     *
     * @param totalAlumnos número de alumnos, debe ser mayor que 0
     */
    public void leerNotas(int totalAlumnos) {

        if (totalAlumnos > 0) {
            notas = new int[totalAlumnos];

            for (int i = 0; i < notas.length; i++) {
                System.out.print("Introduzca la nota del alumno " + i + ": ");
                notas[i] = sc.nextInt();
            }

        } else {
            System.out.println("ERROR: El número de alumnos debe ser mayor que 0.");
            notas = null;   // Indicamos que no hay datos válidos
        }
    }

    /**
     * Imprime todas las notas almacenadas.
     * Si notas es null, informa al usuario.
     */
    public void imprimirNotas() {

        if (notas != null) {
            for (int i = 0; i < notas.length; i++) {
                System.out.println("Nota del alumno " + i + ": " + notas[i]);
            }
        } else {
            System.out.println("No hay notas cargadas. Debe leerlas primero.");
        }
    }

    /**
     * Calcula la media del array notas.
     * Este método tiene **un único return**, como solicitado.
     *
     * @return la media de las notas, o 0 si no se puede calcular
     */
    public double calcularMedia() {

        double media = 0; // Variable que devolveremos al final

        if (notas == null || notas.length == 0) {
            System.out.println("No se puede calcular la media: no hay notas.");
        } else {
            int suma = 0;

            for (int nota : notas) {
                suma += nota;
            }

            media = (double) suma / notas.length;
        }

        return media;   // ÚNICO return del método
    }

    /**
     * Método principal para ejecutar el programa.
     *
     * @param args no utilizado
     */
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.print("Introduzca el número de alumnos: ");
        int total = sc.nextInt();

        Notas notasClase = new Notas();

        notasClase.leerNotas(total);
        notasClase.imprimirNotas();

        double media = notasClase.calcularMedia();
        System.out.println("La media de los alumnos es: " + media);
    }
}