Blog de Programación sobre Java y Javascript
 
Collections en Java: LinkedHashSet
Java

Collections en Java: LinkedHashSet

LinkedHashSet es parte de la API de Java Collection que previamente vimos en otro post, ahora veremos las características y código de ejemplo, que se muestran a continuación:

1. ¿Qué es LinkedHashSet?

Es una lista enlazada que extiende atributos y propiedades de la clase HashSet y que además implementa la interfaz Set.

2. ¿Cuáles son las características de LinkedHashSet ?

  1. No contiene pares clave-valor
  2. No permite duplicados por defecto
  3. El orden almacenado es el mismo en el que se insertó, manteniendo el orden de inserción
  4. Bastante rápido y útil para buscar, insertar o remover elementos
  5. Internamente usa LinkedHashMap  para almacenar objetos
  6. Usa hashCode y equals para comparar objetos
  7. Permite solo un valor null
  8. Consume mas memoria que HashSet

3.¿Cuándo usar LinkedHashSet en Java?

Si queremos mantener el orden de inserción de elementos y hacer operaciones como buscar, agregar, eliminar elementos de forma más rápida

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.*;
 
public class Main {
    public static void main(String[] args) throws Exception {
      
        LinkedHashSet set = new LinkedHashSet();
      
        set.add("F");
        set.add("H");
        set.add("A");
        set.add("V");
        set.add("A");
        set.add("B");
        System.out.println(set);
    }
}

Puedes compilar el codigo anterior aqui: https://paiza.io/projects/vOV9j4XiNpl8oZIGnBKxsQ?language=java
Internamente trabaja convirtiendo en LinkedHashMap, y luego coloca como valor a un objeto constante llamado PRESENT, que es un object, aqui dejo la imagen:

Trabajo internamente de linkedHashSet

Lo que realiza es ingresar cada elemento en un nodo, con el que va a guardarlo como si fuera un hashMap (con clave-valor, siendo clave el propio objeto y el valor sería un objeto constante para este ejemplo: PRESENT ), el resultado será:

Otro ejemplo con LinkedHashSet en Java usando operaciones, lo tenemos en el siguiente bloque de código:

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import java.util.*;
class Libro{
    public Libro(int codigo, String nombre){
        this.codigo=codigo;
        this.nombre=nombre;
    }
    int codigo;
    String nombre;
 
    public int getCodigo(){
        return this.codigo;
    }
    public void setCodigo(int codigo){
        this.codigo=codigo;
    }
    
    public void setNombre(String nombre){
        this.nombre=nombre;
    }
    
    public String getNombre(){
        return this.nombre;
    }
    public String toString(){
        return String.valueOf(codigo)+"-"+nombre;
    }
    
    @Override
    public boolean equals(Object object) {
        Libro libro = (Libro) object;
    
        if(libro.getCodigo() == this.codigo
            && libro.getNombre().equals(this.nombre)){
            return true;
        } else{
            return false;
        }
    }
    
    @Override
    public int hashCode() {
        int value;
        value = this.codigo + nombre.hashCode();
        return value;
    }
}
public class Main {
    public static void main(String[] args) throws Exception {
      
        
        Libro libro1 = new Libro(314123,"Biblia");
        Libro libro2 = new Libro(312412,"La Iliada");
        Libro libro3 = new Libro(3124412,"La divina Comedia");
        
        Set linkedHashSet = new LinkedHashSet();
        linkedHashSet.add(libro1);
        linkedHashSet.add(libro2);
        linkedHashSet.add(libro3);
                
              
        Libro libro4 = new Libro(314123,"Biblia");
        linkedHashSet.add(libro4);
        System.out.println("LinkedHashSet: "+linkedHashSet);
        //tamaño
        System.out.println("Tamaño de linkedHashSet: "+linkedHashSet.size());
        
        //eliminar un nodo
        Libro libro5 = new Libro(312412,"La Iliada");
        linkedHashSet.remove(libro5);
        System.out.println("lista con La Iliada removida: "+linkedHashSet);
        
        //Verificar si existe en el set
         System.out.println("Existe el libro 'Biblia' en el set ? " + linkedHashSet.contains(libro4));
    }
}

Como verás hemos agregado diversas operaciones: desde listas todos los elementos, mostrar el tamaño, remover elemento y verificar si existe el objeto en el linkedHashSet, el resultado es el siguiente:

4. Análisis de Complejidad

Para las operaciones Add, remove, contains son de tiempo de eficiencia O(1) [3]

5. Fuentes

1. Java Generics and Collections, M. Naftaling y P. Wadler
2. Core Java: Volume I Fundamentals, 11th Edition
3. Java 8 Pocket Guide. Robert Liguori & Patricia Liguori

Comments are closed.