Basics

Java Collections

Otro tema en el que creo falta más expertiz a todos los que trabajamos con código y en Java, es al manejo de la API Collections. Todos sabemos de la interfaz List y ArrayList. Pero, ¿sabemos que es una LinkedList, un Stack o un Queue?

Este post tiene como objetivo ver toda este framework que proporciona una arquitectura para almacenar y manipular grupos de objetos.

La API Collections proporciona las interfaces Set, List, Queue y Deque y las clases ArrayList, Vector, LinkedList, PriorityQueue, HashSet, LinkedHashSet y Treeset.

Jerarquía de la API Collections.

Como podemos ver en la imagen, hay una jerarquía, y todos tienen la interfaz Iterable, esto permite que podamos recorrer estos grupos de colecciones. Además, la Interfaz Collection proporciona muchos métodos en común para todos los demás elementos:

Métodos Interfaz Collection

Esta Interfaz Collection, extiende de la Interfaz Iterable, que es la base de todas las classes de Collection. Sólo contiene un método abstracto:

Interfaz Iterable

Como podemos ver, esta Interfaz sólo contiene un método abstracto Iterator, y finalmente, ese Iterator, es una interfaz que contiene 3 métodos:

Interfaz List

La interfaz list es la interfaz hija de la Interfaz Collection. Como características importantes:

  • Estructura en la que se puede almacenar una colección ordenada de objetos.
  • Puede tener datos duplicados.
  • La interfaz es implementada por las clases: ArrayList, LinkedList, Vector y Stack.

Vamos viendo ahora estas clases una por una.

List <String> stringList= new ArrayList();  
List <String> strList = new LinkedList();  
List <Long> longList = new Vector();  
List <Example> exampleList = new Stack();  

Clase ArrayList

Características principales:

  • Permite almacenar datos duplicados de elementos de distintos data types.
  • Mantiene el orden de inserción y es de tipo non-synchronized.
  • Los elementos de los ArrayList pueden ser accedidos aleatoriamente.
  • Es un Array redimensionable que aumenta su tamaño según se necesite.

Clase LinkedList

Características:

  • Internamente usa una lista doblemente vinculada para almacenar los elementos. Esto es, que cada uno de los elementos tiene un puntero al anterior y al siguiente elemento.
  • Puede almacenar elementos duplicados.
  • Mantiene el orden de inserción y es non-synchronized.
  • Bajo ciertas ocasiones es mejor el rendimiento.

Clase Vector

Utiliza un array dinámico para almacenar los elementos.

  • Es similar a ArrayList, pero es synchronized.
  • Puede ser más lento que los arrays estándar, pero puede ser útil en programas donde se necesite mucha manipulación en los arrays.

Clase Stack

Stack hereda de Vector. Tal como crees implementa una estructura de pila, es decir, Last-In-First-Out.

  • Contiene los mismos métodos que Vector y adiciona otros útiles como: peek(), push(object o).

Cuando hablamos de non-synchronized nos referimos que si dos o más hilos acceden de forma concurrente al mismo no asegura la integridad de la información.

Interfaz Queue

La interfaz Queue mantiene un orden de tipo FIFO. Podemos definirla como una lista ordenada que mantiene elementos que serán procesados.

Las clases que implementan la interfaz Queue: PriorityQueue, Deque, ArrayDeque.

Queue<String> priorityQueue = new PriorityQueue();  
Queue<String> arrayDeque = new ArrayDeque();  

Veamos las clases que implementan esta infertaz.

Clase PriorityQueue

  • Implementa la interfaz Queue.
  • Mantiene los elementos u objetos que serán procesados por su prioridad.
  • No acepta valores nulos a ser almacenados en la cola.

Un ejemplo:

public static void main(String[] args) {
        Queue<String> priorityQueue = new PriorityQueue<>();
        priorityQueue.add("Gonzalo");
        priorityQueue.add("Munoz");
        priorityQueue.add("Mendez");

        //Contiene algunos métodos útiles como element que muestra el elemento que viene
        System.out.println(priorityQueue.element());

        //elimina el elemento que viene
        priorityQueue.remove();

        System.out.println(priorityQueue.poll());
    }

Y la consola muestra:

Interfaz Deque

  • Extiende de Interfaz Queue.
  • La ventaja que tiene es que podemos remover y añadir los elementos desde ambos lados.
  • Su nombre proviene de dounble-ended queue.

Clase ArrayDeque

  • Esta clase implementa la interfaz Deque. Nos facilita utilizar la Deque.
  • A excepción de queue, podemos añadir o borrar elementos desde ambos lados de la cola. Los métodos que ayudan a esto: addFirst(Object o) y addLast(Object o).
  • Es más veloz que un ArrayList y un Stack y no tiene restricciones de capacidad.

Interfaz Set

  • Representa un set de elementos sin ordenar y no nos permite elementos duplicados.
  • Podemos almacenar como máximo un valor nulo.
  • Es implementada por clases HashSet, LinkedHashSet y TreeSet.
Set<String> s1 = new HashSet<>();  
Set<Example> s2 = new LinkedHashSet<>();  
Set<Integer> s3 = new TreeSet<>();  

Clase HashSet

  • Implementa la interfaz Set.
  • Representa una colección que utiliza una tabla hash para el almacenaje.
  • Contiene elementos únicos.
HashSet<String> setExample=new HashSet<String>();  
set.add("1");  
set.add("2");  
set.add("3");  
set.add("1"); 

Esto nos retorna todos los elementos únicos.

Clase LinkedHashSet

  • Representa la implementación LinkedList para la interfaz Set.
  • Es similar a HashSet, la diferencia es que usa una lista doblemente enlazada para almacenar data y retener el orden de los elementos.

Interfaz SortedSet

  • Es una interfaz optativa a Set que proporciona una ordenación total de los elementos.
  • Los elementos en SortedSet están ordenados en orden ascendente.
  • Proporciona los métodos adicionales que inhiben el orden natural de los elementos.

Clase TreeSet

  • Es la clase que usa la interfaz SortedSet.
  • Contiene elementos únicos.
  • Están almacenados en orden ascendente.
SortedSet<String> ts
                = new TreeSet<>();

        ts.add("Gonzalo");
        ts.add("Zon");
        ts.add("Alberto");
        Iterator<String> itr = ts.iterator();
        while (itr.hasNext()) {
            System.out.println(itr.next());
        }

Esto nos ordena los elementos y el resultado es:

Categories: Basics, Java

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s