Cargando

Ir a contenido


 


Trabajando con estructuras de datos en Java

En este tutorial veremos cómo podemos trabajar con estructuras de datos, entre las más destacadas veremos los arrays y las colecciones, algo que nos va a dar una base muy importante para poder cumplir el desarrollo de aplicaciones más complejas, ricas y dinámicas.


Escrito por el dic 18 2014 18:27


En algún momento de nuestro desarrollo como creadores de software nos vamos a topar con situaciones en las cuales debemos realizar cosas mucho más complejas dentro de nuestros programas, generalmente esto se traduce en manejo más complejo de datos y una organización diferente de los mismos.

Estructura de datos
Para ello tenemos las estructuras de datos, que nos permiten organizar nuestra información dentro del programa para poder acceder a ellas de una forma ordenada y esquematizada. En Java podemos manejar diferentes tipos de estructuras gracias a sus clases y librerías estándar, por lo que si aprendemos cuales tenemos disponibles es posible que podamos sacar el provecho necesario y así cumplir con nuestras metas.


Estructurando datos con arrays


Un array es un tipo de estructura que tiene una conformación lineal y puede almacenar una cantidad de datos que sean del mismo tipo. Los datos que puede almacenar son tipos primitivos como por ejemplo int, bool, etc. Pero también se puede almacenar tipos de objetos, aunque en este caso se almacena es la referencia al objeto y no el objeto como tal, sin embargo es algo muy útil de saber.

Acceso
Al ser de tipo lineal, el acceso a su contenido debe hacerse de forma secuencial, aunque podemos apuntar directo a un índice del mismo y obtener su contenido, el recorrido en la mayoría de los casos que podemos hacer sobre esta estructura responde a una secuencia de sus índices.


Cuando tenemos un índice por elemento es un array o vector unidimensional, en cambio cuando tenemos más de un índice por elemento estamos hablando de arrays multidimensionales, es decir, dentro de un índice tenemos una estructura interna con sus propios índices.

Declarar un array


Declarar un array es muy sencillo, únicamente debemos definir el tipo de dato que va a almacenar e indicarle las dimensiones con corchetes, luego debemos definir el nombre del mismo y con ello ya podemos empezar a utilizarlo.

A pesar que hay varias formas de declarar un array, la preferida es la forma corta como vemos a continuación:

tipo[] nombreArrary = new tipo[longitud];

En el caso de un array multidimensional podemos hacer lo mismo pero agregando las nuevas capas o dimensiones dentro de la misma declaración, por ejemplo:

Array de dos dimensiones:

tipo[][] nombreArrary = new tipo[longitud][longitud];

Array de tres dimensiones:

tipo[][][] nombreArrary = new tipo[longitud][longitud][longitud];

Lo único que debemos tener en cuenta es que luego de tres dimensiones las cosas se vuelven mucho más complejas, pero ya esto lo va a dictar nuestras necesidades al momento del desarrollo del programa.

Recorrer un array


Para recorrer un array debemos utilizar alguno de los ciclos iterativos que tenemos disponibles, siendo el ciclo for uno de los preferidos, ya que podemos indicar el tamaño del array y recorrer cada uno de sus elementos.

Debemos tener en cuenta que los índices de los arrays empiezan desde cero, por lo que en un array de tres elementos sus índices serían [0], [1], [2], esto hay que tenerlo muy en cuenta ya que al no ser una cuenta tradicional puede llevarnos a la confusión.

Un ejemplo genérico de como recorrer un array es algo como lo siguiente:

for (int i=0; i<LogitudArray; i++) {
System.out.println(nuestroArray[i]);
	 }

De la misma forma que en ese pequeño ejemplo hemos hecho impresión por pantalla del contenido del índice correspondiente, también podemos hacer asignaciones secuenciales y otras operaciones con el array. En el caso de un array multidimensional debemos hacer un ciclo por cada una de las dimensiones que tenemos, es por ello que hablamos de que luego de más de tres dimensiones un array se vuelve muy complejo.

Un ejemplo funcional


Vamos a construir un pequeño código en el cual vamos a definir un array, luego vamos a hacer un recorrido de sus elementos y vamos a mostrarlos por pantalla. Veamos entonces como luce nuestro código:

public class EjemploArray1 {
public static void main(String[] argv) {
	 int[] nuestroArray = new int[12];
	 for (int i=0; i<12; i++) {		
		 nuestroArray[i] = i+1;
			 System.out.println("El contenido del array en: [" + i +"] es: "+ nuestroArray[i]);
	 }	
	 System.out.println("La longitud total del array es: " + nuestroArray.length);
}
}

En este programa lo primero que hacemos luego de definir nuestra clase y el método main es definir un array del tipo int con nombre nuestroArray al cual le asignamos una longitud de 12 elementos, luego con un ciclo for que va del 0 al 11 vamos a asignar un valor a cada uno de los índices del array, luego que lo hacemos inmediatamente imprimimos su valor y finalmente utilizamos la propiedad length del array que nos permite obtener su longitud total y la imprimimos por igual.

Si vemos esto dentro de nuestra consola al ejecutar el programa obtendremos lo siguiente:


Como vemos obtenemos una línea por cada elemento del array y una línea final que nos indica el tamaño real del mismo, notamos también que si contamos del 0 al 11 tenemos 12 elementos, por lo que se demuestra lo que explicamos sobre la cuenta de los índices del array.

Colecciones


El uso de arrays es muy popular y muy útil, sin embargo hay momentos en que se empiezan a ver sus limitaciones, sobre todo cuando trabajamos con estructuras muy dinámicas donde no sabemos cuántos elementos tendremos al final y donde necesitamos un poco más de funcionalidad aparte de las iteraciones para recorrer sus elementos.

Cuando nos vemos en la necesidad de ser más complejos en el manejo de los datos podemos acudir a las colecciones, que no son más que una cantidad de clases agrupadas en la librería estándar de Java java.util y que nos permiten crear otro tipo de estructuras de datos.

En este caso vamos a explorar un poco la clase ArrayList, que nos permite crear listados de arrays como su nombre lo indica, pero que para manipular sus elementos necesitamos hacerlo a través de sus diferentes métodos.

Métodos disponibles en ArrayList


Veamos a continuación un pequeño listado de los métodos disponibles de la clase ArrayList más importantes y que podemos necesitar para crear nuestros programas, si necesitamos algo adicional siempre podremos recurrir a la documentación oficial del lenguaje.

add()
Este método nos permite añadir un elemento a la lista ya sea al final o en una posición determinada esto lo definimos al pasar los parámetros.


clear()
Limpia la estructura al borrar o vaciar todos los elementos que contiene.


get()
Nos devuelve el valor del índice indicado de la lista en cuestión.


remove()
Este método nos permite remover un elemento en particular de la estructura de datos.


toArray()
Este método nos permite hacer una conversión a array del contenido de la lista o estructura de datos.


Declarar una lista


Para declarar una lista con ArrayList, simplemente debemos crear una instancia de esta clase, con ello podremos empezar a trabajar en la asignación de elementos y contenido, para ello podemos ver la siguiente sintaxis:

ArrayList<String> nuestraLista = new ArrayList<>();

Aunque también podemos emplear una declaración y asignación simultanea de elementos como vemos en la siguiente línea de código:

List<String> nuestraLista = Arrays.asList("Pedro", "Juan", "Manuel");

Recorrer una lista


El recorrido de nuestra lista lo podemos lograr con un ciclo iterativo con for() que ya vimos en los arrays, la diferencia es que como no sabemos a ciencia cierta la cantidad de elementos de nuestras listas, debemos definir el limite utilizando el método size() de la misma y para obtener el contenido en un índice determinado utilizamos el método get(). Un ejemplo de la sintaxis para este recorrido podría ser la siguiente:

for (int i = 0; i<nuestraLista .size(); i++) {
		 System.out.println(nuestraLista.get(i));
	 }

Ejemplo práctico


Vamos ahora a crear un pequeño programa donde pongamos en práctica esto que hemos visto sobre ArrayList y de esta forma concretar un aprendizaje sobre dicha estructura de datos:

import java.util.ArrayList;
public class EjemploLista1 {
public static void main(String[] argv) {
		 ArrayList<String> nuestraLista = new ArrayList<>();
	 nuestraLista.add("Pedro");
	 nuestraLista.add("Juan");
	 nuestraLista.add("Francisco");
	 nuestraLista.add("Manolo");
	 nuestraLista.add("Pablo");
	 for (int i=0; i<nuestraLista.size(); i++) {		
		 System.out.println("El contenido de nuestra lista en: [" + i +"] es: "+ nuestraLista.get(i));
	 }
	 System.out.println("La longitud total de nuestra lista es: " + nuestraLista.size());
}
}

En este código vemos que lo primero que hacemos es importar la clase ArrayList del paquete java.util, si no lo hacemos no podremos utilizarla.

Luego hemos definido una nueva lista de elementos tipo String, acto seguido vamos a popular la lista utilizando el método add(), como vemos no hemos definido un límite de elementos, esta lista crecerá de forma dinámica a medida que añadamos elementos a la misma.

Finalmente con un ciclo for() y utilizando el método size() de nuestro objeto lista recorremos sus elementos y para obtener el valor de cada posición utilizamos el método get() con ello podremos imprimir entonces los contenidos. Veamos como luce cuando lo ejecutamos en nuestra consola:



Con esto hemos finalizado este tutorial, ya hemos aprendido a crear y trabajar con las estructuras de datos dentro de Java, ello nos permitirá construir aplicaciones y programas más complejos que cumplan nuestras necesidades.
¿Te ha gustado y ayudado este Tutorial?
Puedes premiar al autor pulsando este botón para darle un punto positivo
  • -
  • 0
8.7
VOTA
5
33.33%
4
66.67%
3
0%
2
0%
1
0%

  Información

  •   Publicado dic 18 2014 18:27
  •   Actualizado dic 18 2014 18:28
  •   Visitas 773
  •   Nivel
    Profesional



Tutoriales Relacionados


Sin comentarios, sé el primero!

No esperes más y entra en Solvetic
Deja tus comentarios y aprovecha las ventajas de la cuenta de usuario ¡Únete!
Demuestra que eres experto!
  ESCRIBIR TUTORIAL
Suscribirse