Listas multidimensionales en Java

La siguiente entrada trata sobre las listas multidimensionales en Java, un concepto que no existe pero cuyo propósito es perfectamente alcanzable utilizando la programación adecuada. Esto intenta mostrarle al lector que las Listas son las mejores opciones disponibles en Java frente a las clásicas matrices y arreglos.

En el día de ayer publiqué un post sobre las listas en Java. En dicho post hablo un poco acerca de los aspectos básicos relacionados a el uso de las listas. Me he referido a este tipo de variables como una opción ante los arreglos y las matrices. Sin embargo en ningún momento mencioné nada sobre el manejo de datos en dos o más dimensiones. Este post lo dedicaré a explicar cómo podemos guardar datos en listas con más de una dimensión.

De hecho, no existe tal cosa como listas multidimensionales. Ese concepto no aplica para este tipo de variables. Entonces, ¿cómo por qué he titulado esta entrada como «Listas multidimensionales en Java»? Pues es simple, podemos crear listas dentro de listas trabajar con instancias de una clase diseñada específicamente para este propósito. Veamos cómo es esto.

Listas dentro de listas

Para los ejemplos a lo largo de esta entrada utilizaré la variable ejemploLista. Cuando declaramos una lista utilizamos la siguiente sintaxis.

En objeto colocamos el tipo de variable que queremos almacenar en la lista. Pero bien podemos lograr que el objeto que usamos como argumento sea otra lista. Esto se daría de la siguiente forma:

Entonces, al colocar una lista dentro de otra podemos guardar información en filas y columnas. Nuestras columnas serían listas y nuestras filas los datos en el interior de dichas listas.

Esta es una visualización gráfica de listas multidimensionales.

Para agregas las sub listas a nuestra variable ejemploLista utilizamos la siguiente instrucción:

Hemos agregado una sub lista al índice 1 de nuestra variable ejemploLista. Ahora si queremos agregar datos a dicha lista pues la llamamos y la modificamos de la siguiente manera:

Al utilizar el método get() estamos llamando a una lista. Sobre dicha lista utilizamos el método add() e insertamos el valor deseado.

Yo soy de los que cree que con el ejemplo es que se aprende, así que vamos a llevar a cabo una pequeña tarea. Crearemos 2 listas, una para la empresa A y otra para la empresa B. En cada lista vamos a insertar los nombres, apellidos, edades e identificaciones de los 3 trabajadores de cada empresa. Estos són:

Entonces vamos a declarar 2 listas, llamadas listaEmpresaA y listaEmpresaB.

Ahora en cada una de las dos listas tenemos que agregar 5 sublistas, lo cual representará nuestras 5 columnas.

Las 5 columnas las guardaré como String. Bien podríamos guardar las edades como un entero (int) pero esto es sólo un ejemplo y no lo voy a tomar en cuenta.

Ahora voy a proceder a introducir los datos en cada una de las listas.

Ahora crearé una rutina para imprimir la información almacenada:

El resultado que obtendremos es el siguiente:

Vemos que efectivamente podemos guardar información y consultarla con este tipo de modelo. Sin embargo esta forma de guardar datos posee una ventaja fundamental y es el hecho de que aunque tenemos información guardada en varias sub listas, estas no se encuentran relacionadas entre sí, por lo que si en algún momento deseamos ordenar la información, modificarla o eliminarla tendremos que hacer lo mismo para todas y cada una de las sub listas contenidas dentro de una lista.

Este tipo de modelo funciona cuando tenemos grandes cantidades de datos y nuestras tareas se basan en hacer consultas sobre dicha información.

El siguiente modelo de almacenamiento de datos presenta una serie de ventajas sobre el modelo de las sub listas y es mi modelo preferido para el almacenamiento de información.

Objetos dentro de Listas

La que es probablemente la mejor forma de usar listas multidimensionales en Java es a través de una clase que utilizamos como objeto dentro de los parámetros de la lista.

En nuestro ejemplo vamos a crear una clase llamada empresa.

Esta clase la colocamos en la misma clase de nuestro ejemplo donde tenemos nuestro método main. En mi caso mi proyecto se llama PHTK_statistics.

Nótese que al declarar una clase y colocar en su interior un método con el nombre de la clase (constructor, en dicho método podemos establecer parámetros para la creación de objetos de esa clase. Al crear un objeto de esa clase se deben establecer obligatoriamente los parámetros indicados en el constructor de la clase.

Dentro de la clase empresa colocamos el constructor:

Si deseamos crear un objeto de esta clase, la declaración se debe hacer de la siguiente forma:

El constructor empresa se invoca cuando se crea una instancia de la clase empresa. En dicho constructor hemos asignado los parámetros a unas variables globales que hemos declarado en la clase.

Ahora vamos a crear nuestra variable ejemploLista nuevamente, utilizando la clase empresa como parámetro. En nuestro método main escribimos:

Ahora vamos a proceder a insertar los mismos datos que utilizamos un poco más arriba con las sub listas.

De esta forma tenemos nuestros datos almacenados en objetos de la clase empresa. Podemos consultar fácilmente la información que hemos almacenado.

Esto generará el siguiente resultado:

Efectivamente tenemos nuestra información tal como la queremos. Pero, el utilizar objetos en vez de listas como parámetros de las listas (valga la redundancia) tiene sus ventajas. Por ejemplo si queremos que los empleados de cada empresa se impriman por separado utilizamos el siguiente código:

Vemos que con la condición:

Solo se aceptan los elementos de la empresa A. Y esta es una ventaja de las listas con objetos ya que están relacionados unos con otros y podemos por ejemplo ordenar datos en base a la edad, al nombre, apellido, ID o cualquier otro parámetro que deseemos. Esta línea arroja el siguiente resultado:

Cuando decidamos eliminar un registro podemos eliminar una fila completa sin tener que eliminar cada columna de cada fila como tendríamos que hacer al usar listas dentro de listas.

Por ejemplo para eliminar los datos relacionados a José Alonso, eliminamos el registro 4 de la siguiente forma:

Es mucho más sencillo que tener que eliminar columna por columna. De hecho este post es un preámbulo de otro que haré sobre las listas y el uso de Lambda Expresions de Java 8, donde el declarar listas como objetos como parámetros es elemental para lograr una mejor eficiencia en nuestro código y aprovechar el poder de las expresiones Lambda.

Sobre el código mostrado en este ejemplo me queda decir pues que a pesar que cuando introducimos la información modificamos directamente las variables declaradas dentro de la clase y cuando hacemos las consultas llamamos a estas variables de forma directa, esta no es la forma «educada» de hacer las cosas en Java. De hecho este método funciona, no hay ningún problema en ello, pero la forma correcta de hacerlo es a través de métodos que declaramos dentro de la clase para la modificación de las variables y las consultas sobre las mismas.

Modificamos nuestra clase empresa de la siguiente manera:

La declaración de las listas y la inserción de datos permanecen invariables. Las consultas varían ligeramente:

Si deseamos modificar cierta información entonces usamos los métodos set(setName(), setLastName…).

Repito, manejar las variables contenidas en la clase empresa de forma directa es perfectamente posible y funcional, pero se prefiere los manejos de variables a través de métodos.

Esto es todo pro ahora. Mi próximo post será sobre manejos de grandes volúmenes de datos contenidos en listas utilizando el poder de las Expresiones Lambda en Java 8.

Espero que la información suministrada se de utilidad para usted. Saludos.