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).
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 é:

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:
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:
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 é:
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:
GO TO FULL VERSION