Colecciones

El lenguaje Java pone a nuestra disposición, gracias a la API Collections, una serie de clases destinadas a la creación de estructuras de datos. Existen 6 tipos:

• Collection: Esta interface representa un grupo general de objetos, donde es posible que el grupo contenga objetos duplicados.
• Set: No hay elementos repetidos. Puede estar o no ordenada. (HashSet y LinkedHashSet).
• SortedSet: Conjunto de elementos en orden ascendente natural o definido por un objeto Comparator (TreeSet).
• List: El orden de los elementos es relevante. Puede tener elementos repetidos. (ArrayList, LinkedList y Vector).
• Map: Estructura de datos en parejas clave/valor, lo que permite localizar un valor en función de una clave dada (HashMap y Hashtable).
• SortedMap: Elementos en orden ascendente natural o definido por un objeto Comparator (TreeMap).

Veamos ahora más detenidamente, las clases más utilizadas:

ArrayList – Listas indexadas:

Es la implementación de un array redimensionable de la interface List. Implementa operaciones de listado. Permite valores null. También provee métodos para manipular el tamaño del array que se utiliza internamente para guardar la lista.

Cada instancia del ArrayList tiene una capacidad. La capacidad es el tamaño del array utilizado para guardar los elementos en la lista. Es, como mínimo, del tamaño de la lista. Conforme se agregan elemento al ArrayList, su capacidad crece automáticamente.

Antes de utilizar la clase ArrayList es necesario realizar el import correspondiente:

import java.util.ArrayList;

Para crear un nuevo ArrayList utilizamos el siguiente código:

ArrayList lista = new ArrayList();

Si se desea recorrer el contenido del ArrayList, utilizamos un iterador:

Iterator i_lista = lista.iterator();
//Mientras que el iterador tenga un proximo elemento
while( i_lista.hasNext() ) {
System.out.println(i_lista.next());
}

Recordar que se debe realizar el import del Iterator para que pueda ser utilizado:

import java.util.Iterator;

LinkedList – Listas enlazadas

LinkedList, al igual que ArrayList es una implementación de la interface List. Implementa operaciones de listado. Además de implementar la interface List, esta clase provee métodos para obtener (get), eliminar(remove) e insertar (insert) elementos al principio y fin de la lista. Estas operaciones permiten a las listas enlazadas ser utilizadas como una pila (stack), o colas doblemente enlazadas.

Es importante mencionar que una lista enlazada es una estructura posicional, es decir, que importa donde estas situado en cada momento. Al método add de la lista añade el elemento al final de la lista, para colocarlo en una posición determinada debes usar un Iterator.

Utilizamos el siguiente import para utilizar la clase LinkedList:

import java.util.LinkedList;

Para declarar un objeto de tipo LinkedList lo hacemos de la siguiente manera:

LinkedList nombre = new LinkedList ();

Para agregar un elemento a la LinkedList lo hacemos de la siguiente manera:

nombre.add(elemento);

Por ejemplo:

Lista.add(“Elemento 1”);

Si deseamos recorrer el contenido de la LinkedList, lo hacemos a través de un iterador. Siempre recordar que se debe incluir el import:

import java.util.Iterator;

y con el siguiente código recorremos los elementos:

Iterator i_linkedlist = linked_list.iterator();
//Mientras que el iterador tenga un proximo elemento
while( i_linkedlist.hasNext() ) {
System.out.println(i_linkedlist.next());
}

Hashset – conjuntos indexados

Esta clase implementa la interface Set, en conjunto con una table hash(actualmente es una instancia a HashMap). Este tipo de clase no garantiza que los elementos van a permanecer ordenados durante su uso. Permite elementos null.

Esta clase ofrece un funcionamiento constante para las operaciones básicas (add, remove, contains y size).

Esta implementación no se encuentra sincronizada. Esto quiere decir que si múltiples hilos acceden a colocar elemento concurrentemente, y al menos uno de esos elementos modifica el Set, debe ser sincronizado externamente.

En el siguiente ejemplo se mostrará como manipular elementos utilizando un HashSet. Estos conjuntos de datos tienen la propiedad de que no se pueden guardar dos elementos con el mismo valor.

El import para la clase HashSet es el siguiente:

import java.util.HashSet;

Primero creamos nuestro objeto de tipo HashSet:

Set hs = new HashSet();

Luego cargamos el conjunto de datos:

hs.add("Erick");
hs.add("Byron");
hs.add("Byron"); // Los elementos solo pueden estar una vez
hs.add("Gerson");

Cuando se agrega un elemento repetido (Byron), este elemento solo aparecerá 1 vez.

Para recorrer nuestro objeto debemos implementar un iterador:

Iterator i_hs = hs.iterator();

Utilizando el método .next() nos movemos a través del iterador:

while (iter.hasNext())
System.out.println(iter.next());

Treeset – Árboles

Esta clase implementa la interface Set, basada en una instancia de TreeMap. Esta clase garantiza que el ordenamiento de los elementos será en orden ascendente, ordenando de acuerdo al orden natural de los elementos, o por el comparador dado en el momento de creación, dependiendo de qué constructor se utilice.

Esta implementación provee método del tipo agregar, eliminar y contiene (contains).

Esta implementación al igual que Hashset, no está sincronizada.

La clase TreeSet es muy similar a la anterior, Hashset, con la diferencia de que esta vez los elementos sí están ordenados. Esta estructura es el típico árbol binario que todos conocemos. El rendimiento es inferior al de los conjuntos indexados, aunque aquí los elementos siempre están ordenados y en algunos casos el rendimiento es mucho mejor que un Array o una lista ordenada.

Antes de utilizar esta clase debe hacerse el siguiente import:

import java.util.TreeSet;

Para crear un nuevo objeto de tipo TreeSet se implementa el siguiente código:

TreeSet lista2 = new TreeSet();

Si se desea agregar elementos, se utiliza el método add de la siguiente manera:

hs.add("Elemento 1");
hs.add("Elemento 2");

Los elementos que agreguemos pueden ser de cualquier tipo. Para el ejemplo, aquí agregamos objetos de tipo String.

Al igual que las clases explicadas anteriormente, para recorrer los elementos de un objeto de Tipo TreeSet se utiliza un iterador:

Iterator i_hs = ts.iterator();

Y mediante el método .hasNext() accedemos a los elementos:

while (iter.hasNext())
System.out.println(iter.next());