Arreglos en Java

En programación, es importante saber cómo funcionan los arreglos, dado que nos ofrecen una forma de manipular conjuntos de elementos en una sola variable. Este artículo te ayudará a entender qué son los arreglos en Java, sus reglas, y todo lo que puedes hacer con ellos.

¿Qué es un arreglo en Java?

Los arreglos en Java son un tipo de contenedor (o estructura de datos) indexado y de tamaño fijo, donde se pueden almacenar múltiples elementos de forma secuencial, siempre que sean del mismo tipo.

Este artículo es sobre arreglos estáticos y unidimensionales, si quieres aprender sobre los arreglos bidimensionales, puedes dirigirte al artículo sobre arreglos bidimensionales en Java. O tal vez estás buscando información sobre arreglos dinámicos, para eso puedes ir al artículo sobre arreglos dinámicos en Java.

A continuación, una representación visual de cómo se almacenan los arreglos unidimensionales en Java, en este ejemplo se muestra un arreglo de números enteros.

Fíjate cómo el primer índice empieza en cero para el primer elemento (7) y termina en cinco para el sexto elemento (12).

¿Cómo declarar un arreglo en Java?

Para declarar un arreglo, se tiene que indicar el tipo de dato de los elementos que contendrá el arreglo, y el nombre del arreglo.

A continuación se muestra un arreglo de números enteros (tipo int),

int[] numeros;

Cabe destacar que los nombres de los arreglos deben seguir las reglas de nomenclatura de identificadores de Java. En este caso, el identificador del arreglo es numeros, pero se pudo haber nombrado de cualquier otra forma.

Aunque la línea de código anterior es válida, aún no se podría utilizar el arreglo, porque no ha sido inicializado. Para inicializarlo, se tiene que crear una nueva instancia y asignarla a la variable. Esto se logra usando la palabra reservada new, seguida del tipo de dato, así como indicando el tamaño del arreglo entre corchetes,

numeros = new int[10];

Una vez creado e inicializado un arreglo en Java, este no puede cambiar su tamaño. Si estás buscando sobre arreglos dinámicos, puedes leer mi artículo sobre arreglos dinámicos en Java

Se puede declarar e instanciar un arreglo en una sola línea de código,

int[] numeros = new int[10];

Todos los tipos de datos disponibles en Java se pueden utilizar para definir arreglos, también se pueden crear arreglos de objetos, ya sea de objetos predefinidos o definidos por el programador.

¿Cómo insertar elementos a un arreglo en Java?

Para insertar un elemento en un arreglo, se debe especificar el nombre del arreglo, en qué índice se desea insertar el elemento, y finalmente el valor del elemento.

Dado el siguiente arreglo de cadenas (tipo String),

String[] nombres = new String[3];

Para insertar el valor “Arturo” en el índice 0, se logra de la siguiente forma,

nombres[0] = "Arturo";

Siempre que se define e instancia un arreglo, Java otorga valores iniciales a todos los índices del arreglo. Hay un valor por defecto para cada tipo de dato, por ejemplo, null para el tipo String, 0 para int, etc.

A continuación se muestra una representación visual del arreglo, después de insertar el valor “Arturo” en el índice 0.

Observa cómo los índices 1 y 2 contienen null, esto es porque Java otorgó esos valores cuando se instanció el arreglo.

Dado que el tipo de dato del arreglo es String, solo se pueden insertar elementos de tipo String. Si se intenta insertar un elemento de otro tipo, Java arrojaría un error.

Por ejemplo, al intentar insertar un número en el arreglo nombres,

nombres[1] = 4;

Se obtiene un error similar al siguiente,

error: incompatible types: int cannot be converted to String nombres[1] = 4;

Para terminar de “llenar” el arreglo, insertemos dos nombres más,

nombres[1] = "Gilberto";
nombres[2] = "Enrique";

En la siguiente imagen se puede ver la representación final del arreglo,

Si se intenta insertar un elemento en un índice que no exista en el arreglo, Java arrojaría una excepción llamada ArrayIndexOutOfBoundsException.

Por ejemplo, se sabe que el índice 3 no está disponible en el arreglo nombres, porque la numeración empieza en 0 y es de tamaño 3, por lo tanto, los índices disponibles son 0, 1, y 2, y si se quiere insertar un elemento en el índice 3,

nombres[3] = "José";

Se obtiene la siguiente excepción,

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3

También se pueden declarar, instanciar, y asignar elementos a los arreglos en una sola línea.

Se podría crear un arreglo e insertar 4 números en cinco líneas de código,

int[] numerosPares =  new int[4];
numerosPares[0] = 2;
numerosPares[1] = 4;
numerosPares[2] = 6;
numerosPares[3] = 8;

Pero se puede lograr lo mismo con una sola línea,

int[] numerosPares = {2,4,6,8};

En la línea anterior, se observa cómo los elementos con los que se está inicializando el arreglo van entre llaves {2,4,6,8}, además en este caso no se debe utilizar la palabra reservada new, ni corchetes.

¿Cómo leer elementos de un arreglo en Java?

Para leer/obtener un elemento de un arreglo en Java, se debe indicar el nombre del arreglo, seguido del índice del elemento que se desea obtener.

Dado el siguiente arreglo de números flotantes (tipo float),

float[] calificaciones = {8.5f, 7.0f, 9.2f};

Para obtener el segundo elemento del arreglo, se logra de la siguiente manera,

calificaciones[1];

Por supuesto, generalmente el programador desea utilizar el valor obtenido del arreglo, de alguna forma u otra, digamos mostrarlo en la consola,

System.out.println(calificaciones[1]);

La línea anterior imprimiría 7.0 en la consola, ya que se insertó ese número en el índice 1 del arreglo.

También, como en el caso de inserción de elementos, si se intenta leer un elemento de un índice que no exista en el arreglo, Java arrojaría la excepción ArrayIndexOutOfBoundsException.

¿Cómo ordenar arreglos en Java?

Java incluye una clase de utilería llamada Arrays, la cual ofrece algunos métodos para operaciones comunes, como el método sort, para ordenamiento de arreglos.

Para ordenar los elementos de un arreglo, solo se debe invocar el método sort de la clase Arrays y pasar el arreglo que queremos ordenar como argumento.

Dado el siguiente arreglo de enteros,

int[] numeros = {5,4,3,2,1};

Para ordenarlo, se usa la siguiente línea de código,

Arrays.sort(numeros);

Por defecto, Java ordenará el arreglo de forma ascendente, en este ejemplo, los elementos del arreglo quedarán ordenados así: {1,2,3,4,5}.

¿Cómo buscar en un arreglo en Java?

En programación, existen diferentes tipos de búsqueda, por ejemplo, búsqueda secuencial, búsqueda binaria, etc., y en Java puedes utilizar todos estos tipos de búsqueda.

Búsqueda secuencial en Java

Para realizar una búsqueda secuencial en un arreglo unidimensional de Java, se puede utilizar algún tipo de ciclo, como for, while, o do while. Decidirse por cuál tipo de ciclo usar, dependerá en gran parte de la situación específica.

Dado el siguiente arreglo de números,

int[] misNumeros = {7, 25, 2, 30, 10, 8, 15, 43};

Para encontrar, por decir el número 15, se puede lograr de la siguiente forma,

boolean encontrado = false;
for (int elemento : misNumeros) {
    if (elemento == 15) {
        encontrado = true;
        break; // Se rompe el ciclo, porque ya se encontró el número 15
    }
}

if (encontrado) {
    System.out.println("Se encontró el valor.");
} else {
    System.out.println("No se encontró el valor.");
}

Búsqueda binaria en Java

La clase Arrays contiene un método para búsquedas llamado binarySearch, pero este método, como su nombre indica, es únicamente para búsqueda binaria, lo cual significa que el arreglo que se pase como argumento tiene que estar ordenado de forma ascendente.

Por eso, si se quiere utilizar este método, uno se debe asegurar de que el arreglo esté ordenado, y si no lo está, ordenarlo primero con el método sort, de lo contrario no hay garantía de que la búsqueda funcione.

El método binarySearch recibe 2 parámetros, el nombre del arreglo donde se desea realizar la búsqueda, y el valor que se quiere buscar en el arreglo.

Si el método encuentra el término de búsqueda, regresa un número entero positivo equivalente al índice donde se encontró, de lo contrario, regresa un número negativo equivalente al índice que le correspondería si se insertara el valor en el arreglo.

Dado el siguiente arreglo,

String[] nombres = {
    "Zulema", 
    "Francisco", 
    "Arturo", 
    "Santiago", 
    "Roberto", 
    "Antonieta"
};

Para encontrar la cadena “Roberto” usando el método binarySearch, se puede lograr así,

// Primero se ordena el arreglo
Arrays.sort(nombres);

// Se invoca el método binarySearch, 
// pasando el arreglo y el término de búsqueda
int indice = Arrays.binarySearch(nombres, "Roberto");

if (indice >= 0) {
    System.out.print("Encontramos a Roberto.");
} else {
    System.out.print("Lo sentimos, no encontramos a Roberto. :(");
}

Es importante que tanto los elementos del arreglo, como el término de búsqueda, sean del mismo tipo de dato, de lo contrario habrá un error de compilación.

Referencias Bibliográficas

Selikoff, S., Boyarsky, J. (2014). OCA: Oracle Certified Associate Java SE 8 Programmer I Study Guide: Exam 1Z0-808. Reino Unido: Wiley.

Referencias Digitales

Tutorial de Arrays en Java, del sitio de la comunidad de Java.

Documentación oficial de la API de la clase Arrays, del sitio de Oracle.