LinkedHashSet em Java

Falando da classe LinkedHashSet em Java, precisamos mencionar que ela implementa a interface Set . LinkedHashSet cria uma coleção que armazena elementos em uma tabela hash, mas mantém a ordem de inserção dos elementos ao contrário de sua contraparte HashSet .

O que é definido em Java

Lembremos brevemente que a interface Set define um conjunto (conjunto). Ele estende Collection e define o comportamento de coleções que não permitem elementos duplicados. Assim, o método add() retorna false se for feita uma tentativa de adicionar um elemento duplicado ao conjunto. A interface não define nenhum método adicional próprio. A interface Set cuida da exclusividade dos objetos armazenados, a exclusividade é determinada pela implementação do método equals() . Portanto, se objetos da classe criada forem adicionados ao Set , é desejável sobrescrever o método equals() .

Classe LinkedHashSet

Antes de falar sobre a classe LinkedHashSet , precisamos mencionar seu parente próximo, a classe HashSet . HashSet implementa a interface Set . Ele cria uma coleção que armazena os elementos em uma tabela hash. Os elementos de uma tabela hash são armazenados como pares chave-valor. A chave especifica a célula (ou segmento) para armazenar o valor. O conteúdo da chave é usado para determinar um valor exclusivo chamado código hash. Podemos pensar em um código hash como um identificador de objeto, embora não precise ser exclusivo. Esse código hash também serve como um índice no qual os dados associados à chave são armazenados. A classe Java LinkedHashSet estende HashSet sem adicionar novos métodos.LinkedHashSet permite verificar rapidamente a existência de uma entrada, assim como HashSet , mas contém uma lista ordenada dentro. Isso significa que ele armazena a ordem de inserção dos elementos. Em outras palavras, LinkedHashSet mantém uma lista encadeada de elementos do conjunto na ordem em que foram inseridos. Isso permite iteração ordenada de inserção em um conjunto. Mas isso faz com que a classe LinkedHashSet execute operações mais demoradas que a classe HashSet .

Recursos importantes do LinkedHashSet

Podemos armazenar elementos exclusivos apenas em um LinkedHashSet
LinketHashSet nos permite extrair elementos na mesma ordem em que inserimos
LinkedHashSet não está sincronizado
LinkedHashSet permite armazenar elementos nulos
LinkedHashSet usa uma técnica de hash para armazenar elementos em um índice especificado com base em um código hash

Métodos LinkedHashSet

Além dos métodos herdados de suas classes pai, o HashSet define os seguintes métodos:

boolean add(Object o) adiciona o elemento especificado a este conjunto se ainda não estiver presente.
void clear() remove todos os elementos deste conjunto.
Object clone() retorna uma cópia rasa desta instância LinkedHashSet : os próprios elementos não são clonados.
boolean contains(Object o) retorna true se este conjunto contiver o elemento especificado.
boolean isEmpty() retorna true se este conjunto não contiver elementos.
Iterator iterator() retorna um iterador sobre os elementos deste conjunto.
boolean remove(Object o) remove o elemento especificado deste conjunto, se presente.
int size() retorna o número de elementos neste conjunto (seu número de elementos).

Exemplos fáceis de LinkedHashSet No exemplo abaixo, mostramos a inicialização do objeto LinkedHashSet e o uso do método add() para preencher o conjunto.

import java.util.LinkedHashSet;
import java.util.Set;

   public class LinkedHashSetEx1 {
       public static void main(String[] args) {
//LinkedHashSet() Init
Set<String> set = new LinkedHashSet<>();
//adding elements to LinkedHashSet
           set.add("Re"); //first added element
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");//last added element


           System.out.println(set);
       }
   }

A saída é:

[Re, Do, Fa, Sol, La, Ti, Mi]

Como você pode ver, os elementos em nosso conjunto apareceram na mesma ordem em que os colocamos.

Exemplo 2. Adicionando uma duplicata ao LinkedHashSet

Vamos colocar em nosso LinkedHashSet 7 elementos com nomes de partituras musicais novamente e colocar um novo elemento que seja igual a um dos elementos colocados antes.

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetEx2 {
   public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("Re");
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");
           set.add("Sol");
           System.out.println(set);
       }
   }

A saída do programa está aqui:

[Re, Do, Fa, Sol, La, Ti, Mi]

A saída do Exemplo dois é exatamente a mesma do primeiro exemplo. Não podemos ter dois elementos semelhantes na coleção LinkedHashSet . Quando tentamos colocar o segundo, ele é simplesmente ignorado.

Exemplo 3. Removendo elementos de LinkedHashSet

import java.util.LinkedHashSet;
import java.util.Set;
   public class LinkedHashSet3 {
       public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("Re");
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");
           System.out.println(set);
           set.remove("Fa");// removing an element from our set
           set.remove("Score");//trying to remove element that isn't in set
           System.out.println(set.remove("Score"));
           System.out.println("Print our set without elements removed: ");
           System.out.println(set);
           set.clear();
           System.out.println("Print out our set after clear command: ");
           System.out.println(set);
       }
   }

A saída do programa está aqui:

[Re, Do, Fa, Sol, La, Ti, Mi] false Imprima nosso conjunto sem elementos removidos: [Re, Do, Sol, La, Ti, Mi] Imprima nosso conjunto após o comando clear: []

Como você pode ver, o método remove() aplicado a um elemento inexistente não resulta em um erro de programa. Ele simplesmente retorna false se o elemento não foi removido e true se o elemento estava no LinkedHashSet e foi removido.

LinkedHashSet vs HashSet

Essas duas classes são parentes próximos. No entanto, dentro do HashSet , ele usa o HashMap para armazenar objetos, enquanto o LinkedHashSet usa o LinkedHashMap . Se você não precisa manter a ordem de inserção, mas precisa armazenar objetos únicos, é mais apropriado usar HashSet . Se você precisa manter a ordem de inserção dos elementos, LinkedHashSet é a sua escolha. O desempenho do LinkedHashSet é um pouco mais lento que o do HashSet porque o LinkedHashSet usa o LinkedList interno para manter a ordem de inserção dos elementos. Vamos a um exemplo:

import java.util.*;

public class LinkedHashSetExample1 {

   public static void main(String[] args) {
       // while regular hash set orders its elements according to its hashcode stamps

       Set<Integer> regularHashSet = new HashSet<>();
       regularHashSet.add(7);
       regularHashSet.add(3);
       regularHashSet.add(5);
       regularHashSet.add(65536);
       regularHashSet.add(9);
       // few duplicates
       regularHashSet.add(5);
       regularHashSet.add(7);

       // next will print:
       // > regularHashSet = [65536, 3, 5, 7, 9]
       System.out.println("regularHashSet = " + regularHashSet);

       // linked hash set keeps order of adding unchanged

       Set<Integer> linkedHashSet = new LinkedHashSet<>();
       linkedHashSet.add(7);
       linkedHashSet.add(3);
       linkedHashSet.add(5);
       linkedHashSet.add(65536);
       linkedHashSet.add(9);
       // few duplicates
       linkedHashSet.add(5);
       linkedHashSet.add(7);

       // next will print:
       // > linkedHashSet = [7, 3, 5, 65536, 9]
       System.out.println("linkedHashSet = " + linkedHashSet);
   }
}

A saída do programa é:

regularHashSet = [65536, 3, 5, 7, 9] linkedHashSet = [7, 3, 5, 65536, 9]

Usando Java LinkedHashSet em aplicativos do mundo real

Como o LinkedHashSet permite verificar rapidamente a existência de uma entrada e também armazenar a ordem, essa coleção parece ser bastante conveniente para eliminar duplicatas de uma lista. Ou, por exemplo, resolver problemas como o último item visto recentemente em minha bolsa. Ou, lembre-se de tal jogo, Pokemon Go? O LinkedHashSet pode armazenar uma lista de Pokémon que você encontrou e a ordem em que eles apareceram em seu caminho. Nesse caso, o Pokémon “repetido” não será mais adicionado à lista. Ou, por exemplo, uma lista de chefes por nível que você já conheceu em algum jogo com níveis. Ou a história da descoberta dos corpos cósmicos. LinkedHashSetpermite que você verifique rapidamente se um corpo de espaço já está na lista ou não e, se não estiver, adicione-o à lista. Vamos dar um exemplo de eliminação de duplicatas.

import java.util.*;

class LinkedHashSetExample2 {
   public static void main(String[] args) {
       List<String> listWithDuplicates = List.of("some","elements","with", "few", "duplicates", "were", "here", "duplicates", "duplicates");

       Set<String> linkedHashSet = new LinkedHashSet<>(listWithDuplicates);
       List<String> listWithoutDuplicates = new ArrayList<>(linkedHashSet);

       // next will print:
       // > listWithDuplicates = [some, elements, with, few, duplicates, here, duplicates, duplicates]
       System.out.println("listWithDuplicates = " + listWithDuplicates);
       // next will print:
       // > listWithoutDuplicates = [some, elements, with, few, duplicates, here]
       System.out.println("listWithoutDuplicates = " + listWithoutDuplicates);

       // -------------------------------------------------------------------------

       // while using regular Hash Set will generally produces some unexpected order
       Set<String> regularHashSet = new HashSet<>(listWithDuplicates);

       // next will print:
       // > linkedHashSet = [some, elements, with, few, duplicates, were, here]
       System.out.println("linkedHashSet = " + linkedHashSet);
       // next will print:
       // > regularHashSet = [here, some, with, duplicates, were, elements, few]
       System.out.println("regularHashSet = " + regularHashSet);
   }
}

A saída do programa está aqui:

listWithDuplicates = [alguns, elementos, com, poucos, duplicados, foram, aqui, duplicados, duplicados] listWithoutDuplicates = [alguns, elementos, com, poucos, duplicados, foram, aqui] linkedHashSet = [alguns, elementos, com, poucos, duplicados , were, here] regularHashSet = [aqui, alguns, com, duplicatas, were, elementos, poucos]