Colecciones en Java

UNIVERSIDAD NACIONAL DE
TRUJILLO
INGENIERÍA DE SISTEMAS
DOCENTE:
Mg. Vidal Melgarejo, Zoraida Yanet
ALUMNOS:
Goicochea Ocas, Luis Enrique

Reyes Julca Christian, Steven
Silva Guevara, Manuel
Vigo Chávez, Daniel
CURSO:
Tecnología de la programación I
TEMA:
Colecciones en Java
CICLO:
IV
2018
TECNOLOGÍA DE LA PROGRAMACIÓN
ÍNDICE
I. INTRODUCCIÓN………………………………………………………………...........................................1
II. CUERPO……………………………………………………………………………………………………………………2
2.1. DEFINICIÓN………………………………………………………………………………………………….4
2.2. LA INTERFAZ COLLECTION……………………………………………………………………………4
2.3. TIPOS DE COLECCIONES EN JAVA…………………………………………………………………5
2.3.1. SET…………………………………………………………………………………………………………5
2.3.2. LIST………………………………………………………………………………………………………..8
2.3.3. QUEUE………………………………………………………………………………………………….11
2.3.4. MAPS……………………………………………………………………………………………………17
2.4. VENTAJAS Y DESVENTAJAS DE LAS COLECCIONES………………………………………19
2.5. CONCLUSIÓN……………………………………………………………………………………………..20
III. BIBLIOGRAFÍA…………………………………………………………………………………………………………21
UNT|GRUPO 2 2
COLECCIONES EN JAVA
I. INTRODUCCIÓN
Las estructuras de datos en Java ofrecen muchas posibilidades y variantes. Por ejemplo, podemos
tener conjuntos sin orden entre los elementos, pero también conjuntos ordenados. Y podemos
tener colas donde el objeto que sale primero no es el primero que llegó, sino el que tiene mayor
prioridad o “urgencia” por salir. Para escoger un tipo de comportamiento u otro existen distintas
clases que se catalogan como colecciones en el API de Java. Incluso existen clases que sirven para
agrupar objetos que Java no clasifica como colecciones, aunque su funcionamiento es muy similar.
Sería el caso de los Maps, objetos que contienen parejas de objetos donde un elemento sirve para
encontrar al otro, al igual que un listín telefónico contiene parejas “Nombre de personas – Datos
de dirección y teléfono” y el nombre de persona es lo que nos sirve para encontrar sus datos
asociados. En la nomenclatura de Java, los Maps no son colecciones. Por eso a veces se usa el
término “contenedores de objetos” para hacer referencia a listas, conjuntos, colas, mapas, etc.
que al fin y al cabo son objetos que contienen más objetos (como una caja que contiene más
cajas).
¿Cómo saber qué clase elegir? Hay varios factores a tener en cuenta, entre ellos el número de
datos que tenemos que gestionar (no es lo mismo trabajar con una colección de 50 objetos que
con una colección de 50.000 objetos) y el tipo de procesos que tenemos que realizar con ellos (no
es lo mismo una lista en que los nuevos elementos se añaden casi siempre al final de la lista que
una lista donde los nuevos elementos se añaden frecuentemente en posiciones intermedias).
Cada clase resulta más eficiente que otra para realizar determinados procesos. Esto es de especial
interés cuando hay que gestionar muchos datos. Si hablamos de sólo unas decenas de datos no
vamos a ser capaces de apreciar diferencias de rendimientos.
La plataforma Java nos proporciona un amplio conjunto de clases dentro del que podemos
encontrar tipos de datos que nos resultarán muy útiles para realizar la programación de
aplicaciones en Java. Estos tipos de datos nos ayudarán a generar código más limpio de una forma
sencilla.
Se proporcionan una serie de operadores para acceder a los elementos de estos tipos de datos.
Decimos que dichos operadores son polimórficos, ya que un mismo operador se puede emplear
para acceder a distintos tipos de datos. Por ejemplo, un operador add utilizado para añadir un
elemento, podrá ser empleado tanto si estamos trabajando con una lista enlazada, con un array,
o con un conjunto por ejemplo.
Este polimorfismo se debe a la definición de interfaces que deben implementar los distintos tipos
de datos. Siempre que el tipo de datos contenga una colección de elementos, implementará la
interfaz Collection. Esta interfaz proporciona métodos para acceder a la colección de elementos,
que podremos utilizar para cualquier tipo de datos que sea una colección de elementos,
independientemente de su implementación concreta.
UNT|GRUPO 2 3
Podemos encontrar los siguientes elementos dentro del marco de colecciones de Java:
 Interfaces para distintos tipos de datos: Definirán las operaciones que se pueden realizar con
dichos tipos de datos. Podemos encontrar aquí la interfaz para cualquier colección de datos,
y de manera más concreta para listas (secuencias) de datos, conjuntos, etc.
 Implementaciones de tipos de datos reutilizables: Son clases que implementan tipos de datos
concretos que podremos utilizar para nuestras aplicaciones, implementando algunas de las
interfaces anteriores para acceder a los elementos de dicho tipo de datos. Por ejemplo,
dentro de las listas de elementos, podremos encontrar distintas implementaciones de la lista
como puede ser listas enlazadas, o bien arrays de capacidad variable, pero al implementar la
misma interfaz podremos acceder a sus elementos mediante las mismas operaciones
(polimorfismo).
 Algoritmos para trabajar con dichos tipos de datos, que nos permitan realizar una ordenación
de los elementos de una lista, o diversos tipos de búsqueda de un determinado elemento,
por ejemplo.
II. CUERPO DEL TEMA

2.1. DEFINICIÓN
Una colección representa un grupo de objetos. Esto objetos son conocidos como
elementos. Cuando queremos trabajar con un conjunto de elementos, necesitamos un
almacén donde poder guardarlos. En Java, se emplea la interfaz genérica Collection para
este propósito. Gracias a esta interfaz, podemos almacenar cualquier tipo de objeto y
podemos usar una serie de métodos comunes, como pueden ser: añadir, eliminar, obtener
el tamaño de la colección. Partiendo de la interfaz genérica Collection extienden otra serie
de interfaces genéricas. Estas subinterfaces aportan distintas funcionalidades sobre la
interfaz anterior.
2.2. LA INTERFAZ “COLLECTION”
La interfaz collection es la superinterfaz de donde heredan la mayoría de las interfaces

utilizadas para el manejo de las colecciones. Es la interfaz raíz de la jerarquía de interfaces.
La interfaz collection forma parte del Collection Framework, un conjunto de interfaces y
clases que representan distintos modos de agrupar objetos, según distintas políticas de
manejo de memoria o acceso a ellos.
Representan un conjunto de objetos, también llamados elementos. Una clase que quiera
comportarse como una Collection deberá implementar esta interfaz, por lo tanto, sus
métodos.
UNT|GRUPO 2 4
2.3. TIPOS DE COLECCIONES EN JAVA

A. Set (Conjunto)
La interfaz Set define una colección que no puede contener elementos duplicados. Esta
interfaz contiene, únicamente, los métodos heredados de Colección añadiendo la
restricción de que los elementos duplicados están prohibidos. Es importante destacar
que, para comprobar si los elementos son elementos duplicados o no lo son, es
necesario que dichos elementos tengan implementada, de forma correcta, los
métodos equals y hashCode. Para comprobar si dos Set son iguales, se comprobarán
si todos los elementos que los componen son iguales sin importar en el orden que
ocupen dichos elementos.
Dentro de la interfaz Set existen varios tipos de implementaciones realizadas dentro
de la plataforma Java. Vamos a analizar cada una de ellas:
• HashSet: esta implementación almacena los elementos en una tabla hash. Es la
implementación con mejor rendimiento de todas pero no garantiza ningún orden
a la hora de realizar iteraciones. Es la implementación más empleada debido a su
rendimiento y a que, generalmente, no nos importa el orden que ocupen los
elementos. Esta implementación proporciona tiempos constantes en las
operaciones básicas siempre y cuando la función hash disperse de forma correcta
los elementos dentro de la tabla hash. Es importante definir el tamaño inicial de la
tabla ya que este tamaño marcará el rendimiento de esta implementación.
• TreeSet: esta implementación almacena los elementos ordenándolos en función
de sus valores. Es bastante más lento que HashSet. Los elementos almacenados
deben implementar la interfaz Comparable. Esta implementación garantiza,
siempre, un rendimiento de log(N) en las operaciones básicas, debido a la
estructura de árbol empleada para almacenar los elementos.
• LinkedHashSet: esta implementación almacena los elementos en función del orden
de inserción. Es, simplemente, un poco más costosa que HashSet.
• EnumSet: EnumSet es un conjunto especializado que solo toma elementos Enum.
Mira la firma de esta clase.
Podemos realizar cualquier operación de recopilación como (agregar, eliminar, etc.)

en Enum. Como EnumSet es una colección, proporciona algunos métodos estáticos
mediante los cuales podemos realizar operaciones de unión, control de rango,
ninguno, etc. Entonces, al utilizar EnumSet, podemos agregar elementos de Enum,
eliminar un elemento o realizar operaciones de unión de forma dinámica.
 CopyOnWriteArraySet: Un Set que utiliza un interno CopyOnWriteArrayList para
todas sus operaciones. Por lo tanto, comparte las mismas propiedades básicas:
UNT|GRUPO 2 5
 Es más adecuado para aplicaciones en las que los tamaños de conjunto

generalmente son pequeños, las operaciones de solo lectura superan
ampliamente las operaciones mutativas, y es necesario evitar la interferencia
entre hilos durante el recorrido.
 Es seguro para subprocesos.
 Mutativas operaciones (add, set, remove, etc.) son caros, ya que por lo general
implican la copia de toda la matriz subyacente.
 Los iteradores no soportan la remove operación mutativa.
 El recorrido a través de los iteradores es rápido y no puede encontrar
interferencias de otros subprocesos. Los iteradores se basan en instantáneas
invariables de la matriz en el momento en que se construyeron los iteradores.
 ConcurrentSkipListSet: ConcurrentSkipListSet es un conjunto concurrente escalable

en Java que utiliza ConcurrentSkipListMap internamente. Aunque se
agregaron colecciones concurrentes
como ConcurrentHashMap y CopyOnWriteArraySet en Java.
ConcurrentSkipListSet en Java
Dado que ConcurrentSkipListSet implementa NavigableSet en Java, es un
conjunto ordenado como TreeSet con la función adicional de ser
concurrente. Lo que esencialmente significa que es una estructura de datos
ordenada que puede ser utilizada por varios subprocesos donde, como TreeSet,
no es seguro para subprocesos. Los elementos de ConcurrentSkipListSet se
mantienen ordenados de acuerdo con su orden natural, o mediante
un Comparador proporcionado en el momento de creación del conjunto, según
el constructor que se utilice. ConcurrentSkipListSet proporciona un constructor
que toma un comparador como parámetro.
ConcurrentSkipListSet (Comparator <? Super E> comparator): construye un
nuevo conjunto vacío que ordena sus elementos según el comparado
especificado. La implementación de ConcurrentSkipListSet proporciona el costo
promedio esperado del tiempo de registro (n) para las operaciones
de contenido, adición y eliminación y sus variantes. Las operaciones de
inserción, eliminación y acceso se ejecutan de forma segura mediante varios
subprocesos.
No hay nulos en ConcurrentSkipListSet
ConcurrentSkipListSet no permite el uso de elementos nulos, ya que los argumentos
nulos y los valores de retorno no se pueden distinguir de manera confiable de la
ausencia de elementos.
Ninguna de estas implementaciones es sincronizada; es decir, no se garantiza el
estado del Set si dos o más hilos acceden de forma concurrente al mismo. Esto se
puede solucionar empleando una serie de métodos que actúan de wrapper para
dotar a estas colecciones de esta falta de sincronización:
UNT|GRUPO 2 6
Una vez explicados los distintos tipos de Set, veremos cómo se crean y mostraremos
sus diferencias en los tiempos de inserción. Como hemos visto anteriormente, el más
rápido debería ser HashSet mientras que, por otro lado, el más lento debería
ser TreeSet. Vamos a comprobarlo con el siguiente código:
A continuación, el resultado de los tiempos obtenidos:
Los tiempos obtenidos demuestran que, efectivamente, el tiempo de inserción es

menor en HashSet y mayor en TreeSet. Es importante destacar que la inicialización del
tamaño inicial del Set a la hora de su creación es importante ya que, en caso de insertar
un gran número de elementos, podrían aumentar el número de colisiones y; con ello,
el tiempo de inserción.
UNT|GRUPO 2 7
B. List (Lista)
Una lista es una colección ordenada de elementos que, a diferencia de la colección
Set, si puede contener elementos duplicados. Es una interfaz que “extiende” la
interfaz Collection. Las Listas están clasificadas como sigue:
1. ArrayList
2. LinkedList
ArrayList:
Un ArrayList es la implementación de la interfaz List donde los elementos pueden ser

añadidos o removidos dinámicamente. Además, el tamaño de la lista incrementa
dinámicamente si son agregados más elementos que el tamaño inicial.
Fig1. Esquema de un ArrayList
Sintaxis:
ArrayList object = new ArrayList();

object.add("2");
object.add(3);
object.add('c');
object.add("Hola");
//Crea un ArrayList que permite el ingreso de cualquier //tipo de dato
ArrayList<Integer> object2 = new ArrayList();
object2.add("2"); //Error
object2.add(3); //Ok
object2.add('c'); //Error
object2.add("Hola"); //Error
UNT|GRUPO 2 8
//Crea un ArrayList que solo permite objetos de tipo //Integer
Los métodos principales de la clase ArrayList son get(), add() y set().
El método set nos permite agregar elementos al ArrayList en cualquier posición

(enviáda por parámetro); si existe un elemento en la posición indicada, este es
eliminado, el método add también nos permite agregar elementos, si no se le pasa un
índice agrega al final, si se pasa el índice por parámetro, agrega el elemento en la
posición indicada y desplaza una posición a la derecha todos los elementos que se
encuentren de la posición indicada en adelante. El método get nos permite leer los
elementos del ArrayList de la posición enviada por parámetro.
Otros métodos son:
Método Descripción
Añade el elemento especificado al

boolean add(Collection c) final de la lista.
Inserta el elemento especificado

void add(int index, Object element)
en la posición indicada.
Elimina todos los elementos de la

void clear()
lista.
Devuelve el índice de la última
int lastIndexOf(Object o) ocurrencia del elemento a buscar.
Si no lo encuentra devuelve -1.
Crea una nueva lista con los
Object clone()
mismos elementos que la
anterior.
Devuelve un array que contiene
Object[] toArray()
todos los elementos de la lista.
Limita la capacidad del ArrayList a

void trimToSize()
su tamaño actual.
LinkedList
LinkedList es una secuencia de Links que contienen elementos. Cada link contiene una
conexión con otro link.
Sintaxis
LinkedList object = new LinkedList();
UNT|GRUPO 2 9
Existen dos tipis de LinkedList: Simple y doble.
 LinkedList simple: En un LinkedList simple, cada nodo guarda el dato de este y un

puntero o referencia al siguiente.
 LinkedList doble: Cada nodo guarda el dato de este, y dos referencias: al nodo
anterior y al nodo siguiente.
Algunos métodos del LinkedList son:
Método Descripción
Es usado para agregar el

boolean add( Object o) elemento especificado al final
de la lista.
Devuelve verdadero si la lista
boolean contains(Object o) contiene al elemento
especificado.
void add (int index, Object Inserta el elemento en el
element) índice especificado.
Inserta el elemento al inicio de

void addFirst(Object o)
la lista.
UNT|GRUPO 2 10
Agrega el elemento al final de

void addLast(Object o)
la lista.
Devuelve el número de
int size() elementos de la lista (también
válido para ArrayList.
Elimina la primera ocurrencia
boolean remove(Object o)
del elemento especificado.
Devuelve el índice de la
primera ocurrencia del objeto
int indexOf(Object element)
especificado, si no lo
encuentra, devuelve -1.
Devuelve el índice de la última
ocurrencia del objeto
int lastIndexOf(Object element)
especificado, si no lo
encuentra, devuelve -1.
Ejemplo de linked list:
LinkedList linked = new LinkedList();
linked.add("2");
linked.add(3);
linked.add('c');
linked.add("Ultimo");
linked.forEach((o) -> {
System.out.println(o.getClass());
}); //Lista todos los elementos
linked.addFirst("Primero"); //añade al final

System.out.println(linked.removeFirst()); //Primero
System.out.println(linked.getFirst()); //2
System.out.println(linked.getLast()); //Ultimo
C. Queue y Deque
Se conoce como cola a una colección especialmente diseñada para ser usada como
almacenamiento temporario de objetos a procesar. Las operaciones que suelen
admitir las colas son “encolar”, “obtener siguiente”, etc. Por lo general las colas siguen
un patrón que en computación se conoce como FIFO (por la sigla en inglés de “First In
- First Out” - “lo que entra primero, sale primero”), lo que no quiere decir otra cosa que
lo obvio: El orden en que se van obteniendo los “siguientes” objetos coincide con el
orden en que fueron introducidos en la cola.
Ventajas:
Muy rápido acceder al primero y último elemento.
Permite crear colas de elementos muy eficientes. (LIFI, FIFO)
UNT|GRUPO 2 11
Inconvenientes:
Acceso lento a los elementos intermedios.
Fig2. Esquema de una queue
Para implementar una cola FIFO en Java la única opción provista por la biblioteca de
colecciones era LinkedList. Esta implementación ofrece una implementación eficiente
de las operaciones “poner primero” y “sacar último”. Sin embargo, aunque la
implentación es la correcta, a nivel de interfaz dejaba algo que desear. Los métodos
necesarios para usar una LinkedList como una cola eran parte solamente de la clase
LinkedList, no existía ninguna interfaz que abstraiga el concepto de “cola”. Esto hacía
imposible crear código genérico que use indistintamente diferentes implementaciones
de colas (que por ejemplo no sean FIFO sino que tengan algún mecanismo de
prioridades). Esta situación cambió recientemente a partir del agregado a Java de dos
interfaces expresamente diseñadas para el manejo de colas: La interfaz Queue tiene
las operaciones que se esperan en una cola. También se creó Deque, que representa a
una “double-ended queue”, es decir, una cola en la que los elementos pueden añadirse
no solo al final, sino también “empujarse” al principio.
LinkedList
Se utiliza la clase LinkedList que implementa una interfaz simple de cola, se añaden
items a la cola utilizando los métodos ADD() y OFFER(). La diferencia que existe entre
ellos es que el método ADD() terminará botando una excepción si es que existe un
problema al añadir un item en la cola, mientras que el método OFFER() solo retornará
falso en caso de que exista el mismo problema. Cual de estos métodos usar depende
de que sistema se desea implementar.
El ejemplo también muestra como eliminar items de la cola utilizando los métodos
REMOVE() y POLL(). Como los métodos previamente mencionados para poder añadir
items a la cola, uno de ellos retornará una excepción si algo sale mal (en este caso, que
no exista ningún item en la cola que se pueda eliminar), mientras que el otro solo
retorna falso.
Exactamente el mismo proceso se aplica para los dos métodos que son utilizados para
UNT|GRUPO 2 12
obtener el primer item que está en la cola. A continuación se explica a mas detalle el
código:
Vamos ahora con un ejemplo práctico de una cola de prioridad:

import java.util.LinkedList;
import java.util.Queue;
/**
*
* @author Silviu Stroe (latzro.com)
*/
public class Main {
/**
* Metodo de ejemplo para una cola
*/
public void queueExample() {
Queue queue = new LinkedList();
//Usando el metodo ADD para anadir.

//Si algo sale mal se botara existira una excepcion.
queue.add("item1");
queue.add("item2");
//Usando el metodo OFFER para anadir.

//Si algo sale mal se retornara un nulo.
queue.offer("Item3");
queue.offer("Item4");
//Eliminar el primer elemento de la cola.

//Si la cola esta vacia una excepcion java.util.NoSuchElementException sera
botada.
System.out.println("remove: " + queue.remove());
//Observar que elemento esta en el primer puesto de la fila sin eliminarlo.

//Si la cola esta vacia una excepcion java.util.NoSuchElementException sera
botada.
System.out.println("element: " + queue.element());
//Eliminar el primer elemento de la cola.

//Si la cola esta vacia, solo se retorna un falso.
UNT|GRUPO 2 13
System.out.println("poll: " + queue.poll());
//Observar que elemento esta en el primer puesto de la fila sin eliminarlo.

//Si la cola esta vacia, solo se retorna un nulo.
System.out.println("peek: " + queue.peek());
/**
* @param args the command line arguments
*/
public static void main(String[] args) {

new Main().queueExample();
}
}
A continuación se muestra el resultado que se obtiene después de compilar el
código:
remove: item1
element: item2
poll: item2
peek: Item3
ArrayDeque
Podemos agregar y remover tanto al inicio como el final de esta colección, la
implementación de matriz de tamaño variable de la interfaz de Deque. Arreglos deques
no tienen restricciones de capacidad; crecen según sea necesario para soportar el uso.
No son seguros para los hilos; en ausencia de sincronización externa, no admiten el
acceso simultáneo de varios subprocesos. Los elementos nulos están prohibidos. Es
probable que esta clase sea más rápida que la Pila cuando se usa como una pila, y más
rápida que la Lista Vinculada cuando se usa como una cola.
La mayoría de las operaciones de ArrayDeque se ejecutan en tiempo constante
amortizado. Las excepciones incluyen remove, removeFirstOccurrence,
removeLastOccurrence, contiene, iterator.remove () y las operaciones masivas, todas
las cuales se ejecutan en tiempo lineal.
Constructores públicos
ArrayDeque()
Construye un arreglo de matriz vacío con una capacidad inicial suficiente para
albergar 16 elementos.
UNT|GRUPO 2 14
ArrayDeque(int numElements)
Construye un arreglo de matriz vacío con una capacidad inicial suficiente para
contener el número especificado de elementos.
ArrayDeque(Collection<? extends E> c)
Construye un deque que contiene los elementos de la colección especificada, en el
orden en que son devueltos por el iterador de la colección.
Vamos ahora con un ejemplo práctico:
A continuación, se muestra el resultado que se obtiene después de compilar el

código:
PriorityQueue
Se utiliza una PriorityQueue cuando se supone que los objetos deben procesarse según
la prioridad. Se sabe que una cola sigue el algoritmo de Primero en entrar, primero en
salir, pero a veces los elementos de la cola deben procesarse de acuerdo con la
prioridad, que es cuando el PriorityQueue entra en juego.
UNT|GRUPO 2 15
El PriorityQueue se basa en el montón de prioridad. Los elementos de la cola de

prioridad se ordenan de acuerdo con el orden natural, o por un Comparador
proporcionado en el momento de la construcción de la cola, según el constructor que
se utilice. Algunos puntos importantes en la cola de prioridad son los siguientes:
 PriorityQueue no permite punteros NULL.

 No podemos crear PriorityQueue de objetos que no son comparables
 PriorityQueue son colas independientes.
 El encabezado de esta cola es el elemento mínimo con respecto al orden
especificado. Si varios elementos están vinculados por el menor valor, la cabeza es
uno de esos elementos: los vínculos se rompen arbitrariamente.
 Las operaciones de recuperación de cola sondean, eliminan, miran y el elemento
accede al elemento al principio de la cola.
 Hereda métodos de AbstractQueue, AbstractCollection, Collection y Object class.
Constructores de la clase PriorityQueue

 PriorityQueue (): crea un PriorityQueue con la capacidad inicial predeterminada
(11) que ordena sus elementos según su orden natural.
 PriorityQueue (Colección c): crea un PriorityQueue que contiene los elementos de

la colección especificada.
 PriorityQueue (int initialCapacity): crea un PriorityQueue con la capacidad inicial

especificada que ordena sus elementos según su orden natural.
 PriorityQueue (int initialCapacity, Comparator comparator): crea un PriorityQueue

con la capacidad inicial especificada que ordena sus elementos de acuerdo con el
comparador especificado.
 PriorityQueue (PriorityQueue c): crea un PriorityQueue que contiene los elementos

en la cola de prioridad especificada.
 PriorityQueue (SortedSet c) : crea un PriorityQueue que contiene los elementos en

el conjunto ordenado especificado
UNT|GRUPO 2 16
Vamos ahora con un ejemplo práctico de una cola de prioridad:
A continuación, se muestra el resultado que se obtiene después de compilar el código:
D. Maps
La interfaz Map asocia claves a valores. Esta interfaz no puede contener claves
duplicadas y; cada una de dichas claves, sólo puede tener asociado un valor como
máximo.
UNT|GRUPO 2 17
Dentro de la interfaz Map existen varios tipos de implementaciones realizadas dentro
de la plataforma Java. Vamos a analizar cada una de ellas:
 HashMap: esta implementación almacena las claves en una tabla hash. Es la
implementación con mejor rendimiento de todas, pero no garantiza ningún orden a la
hora de realizar iteraciones. Esta implementación proporciona tiempos constantes en las
operaciones básicas siempre y cuando la función hash disperse de forma correcta los
elementos dentro de la tabla hash. Es importante definir el tamaño inicial de la tabla ya
que este tamaño marcará el rendimiento de esta implementación.
 TreeMap: esta implementación almacena las claves ordenándolas en función de sus
valores. Es bastante más lento que HashMap. Las claves almacenadas deben
implementar la interfaz Comparable. Esta implementación garantiza, siempre, un
rendimiento de log(N)en las operaciones básicas, debido a la estructura de árbol
empleada para almacenar los elementos.
 LinkedHashMap: esta implementación almacena las claves en función del orden de
inserción. Es, simplemente, un poco más costosa que HashMap.
Ninguna de estas implementaciones es sincronizada; es decir, no se garantiza el estado
del Map si dos o más hilos acceden de forma concurrente al mismo. Esto se puede solucionar
empleando una serie de métodos que actúan de wrapper para dotar a estas colecciones de
esta falta de sincronización:
UNT|GRUPO 2 18
A continuación vamos a ver cómo se crean los distintos tipos de interfaces:
El cuándo usar una implementación u otra de Map variará en función de la situación en la
que nos encontremos. Generalmente, HashMap será la implementación que usemos en la
mayoría de situaciones. HashMap es la implementación con mejor rendimiento (como se ha
podido comprobar en el análisis de Set), pero en algunas ocasiones podemos decidir
renunciar a este rendimiento a favor de cierta funcionalidad como la ordenación de sus
elementos.
2.4. VENTAJAS Y DESVENTAJAS DE LAS COLECCIONES
COLECCIÓN VENTAJAS DESVENTAJAS

 No tiene acceso
 No se permiten elementos aleatorio.
duplicados.  Poca eficiencia
SET  Uso sencillo del método add a la hora de
que además asegura no ordenar
elementos duplicados. elementos(y no
siempre se
puede).
 Acceso aleatorio.
 Están  Bajo
ordenadas(collection,short()) rendimiento en
 Añadir/eliminar sin operaciones
restricción. concreta
LIST que se
 ListIterador modifica en resolverían
cualquier dirección. mejor en otras
 Sintaxis similar a los arrays. interfaces.
UNT|GRUPO 2 19
 Muy rápido al acceder al  Acceso lento a

primer y último elemento. los elementos
QUEUE  Permite crear colas de intermedios.
elementos muy
eficientes(LIFO/FIFO).
 Asociación clave-> valor.  Poca eficiencia
 No claves iguales. comparado con
MAP
las otras
colecciones.
2.5. CONCLUSIÓN
Como hemos visto a lo largo del desarrollo del tema, las colecciones en Java proporcionan
una serie de estructuras muy variadas para almacenar datos. Estas estructuras, ofrecen
diversas funcionalidades: ordenación de elementos, mejora de rendimiento, rango de
operaciones… Es importante conocer cada una de ellas para saber cuál es la mejor
situación para utilizarlas. Un buen uso de estas estructuras mejorará el rendimiento de
nuestra aplicación.
Para conocer qué tipo de colección usar, podemos emplear el siguiente diagrama:
UNT|GRUPO 2 20
III. BIBLIOGRÁFIA
 https://www.adictosaltrabajo.com/2015/09/25/introduccion-a-colecciones-en-
java/
 http://di002.edv.uniovi.es/~cueva/asignaturas/extension/2006/Java/files/coleccio
nes.pdf
 http://www.jtech.ua.es/j2ee/publico/lja-2012-13/sesion02-apuntes.html
 https://www.youtube.com/watch?v=1JlTVtrHdKs
 https://www.youtube.com/watch?v=bTu-fz1JmWQ&t=720s
 https://es.slideshare.net/rennybatista/java-colecciones
 https://es.slideshare.net/JahyrAndre/colecciones-en-java-76602029
 DEAN, John & DEAN, Raymond. Introducción a la programación con Java. 1ra ed.
México. Mc Graw Hill. 2008. 730 p. ISBN: 978-970-10-7278-3.
UNT|GRUPO 2 21

Colecciones en Java

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Colecciones en Java

Transféré par

Droits d'auteur :

Formats disponibles

UNIVERSIDAD NACIONAL DE

Goicochea Ocas, Luis Enrique

II. CUERPO DEL TEMA

2.2. LA INTERFAZ “COLLECTION”

La interfaz collection es la superinterfaz de donde heredan la mayoría de las interfaces

2.3. TIPOS DE COLECCIONES EN JAVA

Podemos realizar cualquier operación de recopilación como (agregar, eliminar, etc.)

 Es más adecuado para aplicaciones en las que los tamaños de conjunto

 ConcurrentSkipListSet: ConcurrentSkipListSet es un conjunto concurrente escalable

A continuación, el resultado de los tiempos obtenidos:

Los tiempos obtenidos demuestran que, efectivamente, el tiempo de inserción es

Un ArrayList es la implementación de la interfaz List donde los elementos pueden ser

Fig1. Esquema de un ArrayList

ArrayList object = new ArrayList();

ArrayList<Integer> object2 = new ArrayList();

//Crea un ArrayList que solo permite objetos de tipo //Integer

Los métodos principales de la clase ArrayList son get(), add() y set().

El método set nos permite agregar elementos al ArrayList en cualquier posición

Otros métodos son:

Añade el elemento especificado al

Inserta el elemento especificado

Elimina todos los elementos de la

Limita la capacidad del ArrayList a

LinkedList object = new LinkedList();

Existen dos tipis de LinkedList: Simple y doble.

 LinkedList simple: En un LinkedList simple, cada nodo guarda el dato de este y un

Algunos métodos del LinkedList son:

Es usado para agregar el

Inserta el elemento al inicio de

Agrega el elemento al final de

linked.addFirst("Primero"); //añade al final

Fig2. Esquema de una queue

Vamos ahora con un ejemplo práctico de una cola de prioridad:

public class Main {

Queue queue = new LinkedList();

//Usando el metodo ADD para anadir.

//Usando el metodo OFFER para anadir.

//Eliminar el primer elemento de la cola.

//Observar que elemento esta en el primer puesto de la fila sin eliminarlo.

//Eliminar el primer elemento de la cola.

System.out.println("poll: " + queue.poll());

//Observar que elemento esta en el primer puesto de la fila sin eliminarlo.

public static void main(String[] args) {

A continuación, se muestra el resultado que se obtiene después de compilar el

El PriorityQueue se basa en el montón de prioridad. Los elementos de la cola de

 PriorityQueue no permite punteros NULL.

Constructores de la clase PriorityQueue

 PriorityQueue (Colección c): crea un PriorityQueue que contiene los elementos de

 PriorityQueue (int initialCapacity): crea un PriorityQueue con la capacidad inicial

 PriorityQueue (int initialCapacity, Comparator comparator): crea un PriorityQueue

 PriorityQueue (PriorityQueue c): crea un PriorityQueue que contiene los elementos

 PriorityQueue (SortedSet c) : crea un PriorityQueue que contiene los elementos en

Vamos ahora con un ejemplo práctico de una cola de prioridad:

A continuación, se muestra el resultado que se obtiene después de compilar el código:

Dentro de la interfaz Map existen varios tipos de implementaciones realizadas dentro

de la plataforma Java. Vamos a analizar cada una de ellas:

 HashMap: esta implementación almacena las claves en una tabla hash. Es la

implementación con mejor rendimiento de todas, pero no garantiza ningún orden a la

hora de realizar iteraciones. Esta implementación proporciona tiempos constantes en las

elementos dentro de la tabla hash. Es importante definir el tamaño inicial de la tabla ya

que este tamaño marcará el rendimiento de esta implementación.

 TreeMap: esta implementación almacena las claves ordenándolas en función de sus

implementar la interfaz Comparable. Esta implementación garantiza, siempre, un

rendimiento de log(N)en las operaciones básicas, debido a la estructura de árbol