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.

Contar los elementos que contiene un array

Cuando utilizamos arrays, es muy molesto contar los elementos de un array para saber su tamaño. Afortunadamente, todo objeto de tipo array tiene una variable de instancia llamada length que contiene el tamaño del array, es decir, el número de celdas.

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.

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:

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

Método	Descripción
static void fill(T[] array, T valor)	Llena el array con el valor indicado: todos los elementos iguales.
static boolean equals(T[] a1, T[] a2)	Chequea si los arrays son idénticos, comprobando valores primitivos (==) y referencias (con equals).
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.
static String toString(T[] datos)	Genera una cadena para impresión.
static String deepToString(T[] datos)	Genera una cadena para impresión, incluso si se trata de un array multidimensional.
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).
static T[] copyOfRange(T[] datos, int desde, int hasta)	Copia un segmento de los datos.
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.
static void sort(T[] datos)	Ordena el array.
static void sort(T[] datos, int desde, int hasta)	Ordena el array entre las posiciones indicadas.