LinkedHashSet do Java

Neste tutorial, vamos aprender o LinkedHashSet e seus métodos no Java com exemplos.

A classe LinkedHashSet do Java Collection Framework fornece funcionalidades de estrutura de dados de tabela hash e lista ligada.

Ela implementainterface Set.

Os elementos do LinkedHashSet são armazenados em um estilo semelhante aHashSetna tabela hash.

Mas, o conjunto hash de lista mantém uma lista dupla para todos os seus elementos internamente. A lista define a ordem de inserção dos elementos na tabela hash.

Criar um LinkedHashSet

Para criar um conjunto hash de lista, devemos primeiro importar o pacote java.util.LinkedHashSet.

Depois de importar o pacote, você pode criar um conjunto hash de lista no Java.

//Com8capacidade e 0.75LinkedHashSet com fator de carga
LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);

Aqui, criamos um conjunto hash de lista chamado numbers.

Atenção, a expressão new LinkedHashSet<>(8, 0.75) Aqui, o primeiro parâmetro éCapacidadeO segundo parâmetro éFator de carga.

• capacity - A capacidade deste conjunto hash é8Isso significa que ela pode armazenar8elementos.

• loadFactor- O fator de carga deste conjunto hash é 0.6Isso significa que, desde que nossa tabela hash esteja cheia60%, o elemento será movido para a nova tabela hash, cujo tamanho é o dobro da tabela hash original.

Capacidade e fator de carga padrão

Podemos criar conjuntos hash encadeados sem definir sua capacidade e fator de carga. Por exemplo,

//LinkedHashSet com capacidade e fator de carga padrão
LinkedHashSet<Integer> numbers1　= new LinkedHashSet<>();

Padrão,

• A capacidade do conjunto hash encadeado será16

• O fator de carga será 0.75

Criar LinkedHashSet a partir de outros conjuntos

Aqui está como criamos um conjunto hash encadeado que contém todos os elementos de outros conjuntos.

import java.util.LinkedHashSet;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar uma arrayList de números pares
　　　　　　　　ArrayList<Integer> evenNumbers = new ArrayList<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("ArrayList: ",　+　evenNumbers);
　　　　　　　　//Criar LinkedHashSet a partir de ArrayList
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
　　　　　　　　System.out.println("LinkedHashSet: ",　+　numbers);
　　　　}
}

Resultados de saída

ArrayList: [2,　4]
LinkedHashSet: [2,　4]

Métodos do LinkedHashSet

A classe LinkedHashSet fornece métodos que nos permitem executar várias operações no conjunto hash encadeado.

Inserir o elemento no LinkedHashSet

• add() - Inserir o elemento especificado no conjunto hash da lista encadeada

• addAll() - Inserir todos os elementos do conjunto especificado no conjunto hash da lista encadeada

Por exemplo,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> evenNumber = new LinkedHashSet<>();
　　　　　　　　//　Usar o método add()
　　　　　　　　evenNumber.add(2);
　　　　　　　　evenNumber.add(4);
　　　　　　　　evenNumber.add(6);
　　　　　　　　System.out.println("LinkedHashSet: ",　+　evenNumber);
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　
　　　　　　　　//Usar o método addAll()
　　　　　　　　numbers.addAll(evenNumber);
　　　　　　　　numbers.add(5);
　　　　　　　　System.out.println("Novo LinkedHashSet: ",　+　numbers);
　　　　}
}

Resultados de saída

LinkedHashSet: [2,　4,　6]
Novo LinkedHashSet: [2,　4,　6,　5]

Acessar elementos do LinkedHashSet

Para acessar os elementos do conjunto hash da lista encadeada, podemos usar o método iterator(). Para usar este método, devemos importar o pacote java.util.Iterator. Por exemplo,

import java.util.LinkedHashSet;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("LinkedHashSet: ",　+　numbers);
　　　　　　　　//Chamar o método iterator()
　　　　　　　　Iterator<Integer> iterate = numbers.iterator();
　　　　　　　　System.out.print("Usar Iterator do LinkedHashSet: ")}
　　　　　　　　//Acessar elemento
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de saída

LinkedHashSet: [2,　5,　6]
Usar LinkedHashSet com Iterator:　2,　5,　6,

Considerações:

• hasNext() retorna true se houver próximo elemento no hash da lista encadeada

• next() retorna o próximo elemento do hash da lista encadeada

Remover elemento do HashSet

• remove() - Remover o elemento especificado do hash da lista

• removeAll() - Remover todos os elementos do hash da lista

Por exemplo,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("LinkedHashSet: ",　+　numbers);
　　　　　　　　//Usar o método remove()
　　　　　　　　boolean value1　= numbers.remove(5);
　　　　　　　　System.out.println("5Removido? "　+　value1);
　　　　　　　　boolean value2　= numbers.removeAll(numbers);
　　　　　　　　System.out.println("Se todos os elementos foram removidos? ",　+　value2);
　　　　}
}

Resultados de saída

LinkedHashSet: [2,　5,　6]
5Removido? true
Se todos os elementos foram removidos? true

Métodos de operação LinkedHashSet

Os métodos de várias classes LinkedHashSet também podem ser usados para executar várias operações de conjunto.

união

Para executar a união entre dois conjuntos, podemos usar o método addAll(). Por exemplo,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　evenNumbers);
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　numbers);
　　　　　　　　//união dos dois conjuntos
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("união: ",　+　numbers);
　　　　}
}

Resultados de saída

LinkedHashSet1: [2,　4]
LinkedHashSet2: [1,　3]
união: [1,　3,　2,　4]

interseção

Para executar a interseção entre dois conjuntos, podemos usar o método retainAll(). Por exemplo,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　primeNumbers);
　　　　　　　　LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　evenNumbers);
　　　　　　　　//interseção do conjunto
　　　　　　　　evenNumbers.retainAll(primeNumbers);
　　　　　　　　System.out.println("interseção do conjunto: ",　+　evenNumbers);
　　　　}
}

Resultados de saída

LinkedHashSet1: [2,　3]
LinkedHashSet2: [2,　4]
interseção do conjunto: [2]

diferença de conjuntos

Para calcular a diferença entre dois conjuntos, podemos usar o método removeAll(). Por exemplo,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　primeNumbers.add(5);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　primeNumbers);
　　　　　　　　LinkedHashSet<Integer> oddNumbers = new LinkedHashSet<>();
　　　　　　　　oddNumbers.add(1);
　　　　　　　　oddNumbers.add(3);
　　　　　　　　oddNumbers.add(5);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　oddNumbers);
　　　　　　　　//LinkedHashSet1e LinkedHashSet2diferença entre
　　　　　　　　primeNumbers.removeAll(oddNumbers);
　　　　　　　　System.out.println("Diferença: ",　+　primeNumbers);
　　　　}
}

Resultados de saída

LinkedHashSet1: [2,　3,　5]
LinkedHashSet2: [1,　3,　5]
Diferença: [2]

Subconjunto

Para verificar se um conjunto é subconjunto de outro, podemos usar o método containsAll(). Por exemplo,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　numbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　numbers);
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　primeNumbers);
　　　　　　　　//Verificar se primeNumbers é um subconjunto de numbers
　　　　　　　　boolean result = numbers.containsAll(primeNumbers);
　　　　　　　　System.out.println("LinkedHashSet2É um LinkedHashSet1É um subconjunto? "　+　result);
　　　　}
}

Resultados de saída

LinkedHashSet1: [1,　2,　3,　4]
LinkedHashSet2: [2,　3]
LinkedHashSet2É um LinkedHashSet1É um subconjunto? true

Outros métodos do LinkedHashSet

Diferenças entre LinkedHashSet e HashSet

LinkedHashSet e HashSet implementam a interface Set. No entanto, existem algumas diferenças entre eles.

• LinkedHashSet mantém uma lista encadeada internamente. Portanto, ele mantém a ordem de inserção de seus elementos.

• LinkedHashSet requer mais espaço de armazenamento do que HashSet. Isso é porque o LinkedHashSet mantém uma lista encadeada internamente.

• O desempenho do LinkedHashSet é mais lento do que o HashSet. Isso é porque há uma lista encadeada no LinkedHashSet.

Diferenças entre LinkedHashSet e TreeSet

A seguir estão as principais diferenças entre LinkedHashSet e TreeSet:

• A classe TreeSet implementa a interface SortedSet. Isso é o motivo pelo qual os elementos no conjunto de árvores estão ordenados. No entanto, a classe LinkedHashSet apenas mantém a ordem de inserção de seus elementos.

• TreeSet geralmente é mais lento do que LinkedHashSet. Isso porque, a cada vez que um elemento é adicionado ao TreeSet, ele deve executar uma operação de ordenação.

• LinkedHashSet permite a inserção de valores nulos. No entanto, não podemos inserir valores nulos em TreeSet.