Curso_Programación Orientada a Objetos en Java: Tema 2.3

En la interfaz set se define una colección la cual no puede contener elementos duplicados. Debemos tener en cuenta que esta interfaz contiene, solamente, los métodos heredados de Collection añadiendo la restricción de que no contiene elementos duplicados en su colección. 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.

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.

Ahora veamos un ejemplo simple de una implementación del HashSet. Notemos que los elementos iteran en una colección desordenada

import java.util.*;  

public class HashSet_Prueba{  
 public static void main(String args[]){  
  //Creating HashSet and adding elements  
    HashSet<String> set= new HashSet<String>();  
           set.add("One");    
           set.add("Two");    
           set.add("Three");   
           set.add("Four");  
           set.add("Five");  
           Iterator<String> i=set.iterator();  
           while(i.hasNext())  
           {  
           System.out.println(i.next());  
           }  
 }  
}

En el ejemplo anterior se noto un manejo básico de la creación de elementos en el HashSet, en el siguiente ejemplo se ilustran algunas operaciones básicas de HashSet:

public class HashSet_Prueba{

  public static void main(String[]args) 
    { 
        HashSet<String> h = new HashSet<String>(); 
  
        // Añadiendo elementos en HashSet usando add() 
        h.add("India"); 
        h.add("Australia"); 
        h.add("South Africa"); 
        h.add("India");// adding duplicate elements 
  
        // Mostrando el HashSet 
        System.out.println(h); 
        System.out.println("List contains India or not:" + 
                           h.contains("India")); 
  
        // Eliminar elementos de HashSet utilizando remove() 
        h.remove("Australia"); 
        System.out.println("List after removing Australia:"+h); 
  
        // Iterando sobre los item del Set
        System.out.println("Iterating over list:"); 
        Iterator<String> i = h.iterator(); 
        while (i.hasNext()) 
            System.out.println(i.next()); 
    } 
}

La salida que tenemos del código anterior es:

[South Africa, Australia, India]

List contains India or not:true

List after removing Australia:[South Africa, India]

Iterating over list:

South Africa

India

LinkedHashSet:

Esta implementación es similar a que observamos con anterioridad, solo que esta posee una especialidad y su tabla de dispersión es doblemente enlazada. Por lo tanto, las operaciones básicas seguirán teniendo coste constante, con la carga adicional que supone tener que gestionar los enlaces. Sin embargo habrá una mejora en la iteración, ya que al establecerse enlaces entre los elementos no tendremos que recorrer todas las entradas de la tabla, el coste sólo estará en función del número de elementos insertados. Estos enlaces definirán el orden en el que se insertaron en el conjunto, por lo que el orden de iteración será el mismo orden en el que se insertaron.

import java.util.*;  

public class LinkedHashSetPrueba{  
    public static void main(String[] args)  
    {   
        LinkedHashSet<String> linkedset =  
                           new LinkedHashSet<String>();   
  
        // Añadiendo elemento a LinkedHashSet   
        linkedset.add("A");   
        linkedset.add("B");   
        linkedset.add("C");   
        linkedset.add("D");  
  
        // Esto no agregará nuevo elemento ya que A ya existe  
        linkedset.add("A");  
        linkedset.add("E");   
  
        System.out.println("Size of LinkedHashSet = " + 
                                    linkedset.size());   
        System.out.println("Original LinkedHashSet:" + linkedset);   
        System.out.println("Removing D from LinkedHashSet: " + 
                            linkedset.remove("D"));   
        System.out.println("Trying to Remove Z which is not "+ 
                            "present: " + linkedset.remove("Z"));   
        System.out.println("Checking if A is present=" +  
                            linkedset.contains("A")); 
        System.out.println("Updated LinkedHashSet: " + linkedset);   
    } 
}

La salida que tenemos del código anterior es:

Size of LinkedHashSet = 5
Original LinkedHashSet:[A, B, C, D, E]
Removing D from LinkedHashSet: true
Trying to Remove Z which is not present: false
Checking if A is present=true
Updated LinkedHashSet: [A, B, C, E]

TreeSet:

Esta implementación almacena los elementos ordenándolos en función de sus valores. Es más lento que HashSet . 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.
Ahora veamos un ejemplo simple de una implementación del TreeSet.

import java.util.*;  

public class TreeHashSetPrueba{  
    public static void main(String[] args) 
    { 
        TreeSet<String> ts1 = new TreeSet<String>(); 
  
        // Elements are added using add() method 
        ts1.add("A"); 
        ts1.add("B"); 
        ts1.add("C"); 
  
        // Duplicates will not get insert 
        ts1.add("C"); 
  
        // Elements get stored in default natural 
        // Sorting Order(Ascending) 
        System.out.println(ts1); 
    }
}

En esta parte del curso observamos una parte de las colecciones conocidas como Set, de las cuales visualizamos como son utilizadas en Java. Ahora tu puedes seguir trabajando y revisando con algunos ejemplos el como utilizar esta colección.

Última modificación: miércoles, 16 de marzo de 2022, 09:55

Tema 2.3 - Set

HashSet:

LinkedHashSet:

TreeSet:

Contáctanos

Categorías de Cursos

Certificaciones

Q-Vision Technologies

Soporte