Java LinkedHashSet

Neste tutorial, aprenderemos sobre a classe Java LinkedHashSet e seus métodos com a ajuda de exemplos.

O LinkedHashSet A classe da estrutura de coleções Java fornece funcionalidades da estrutura de dados da tabela de hash e da lista vinculada.

Ele implementa a interface Set.

Elementos de LinkedHashSet são armazenados em tabelas de hash semelhantes a HashSet.

No entanto, conjuntos de hash vinculados mantêm uma lista duplamente vinculada internamente para todos os seus elementos. A lista vinculada define a ordem em que os elementos são inseridos nas tabelas de hash.

Criar um LinkedHashSet

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

Depois de importar o pacote, veja como podemos criar conjuntos de hash vinculados em Java.

// LinkedHashSet with 8 capacity and 0.75 load factor
LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);

Aqui, criamos um conjunto de hash vinculado chamado numbers .

Observe, a parte new LinkedHashSet<>(8, 0.75) . Aqui, o primeiro parâmetro é capacidade e o segundo parâmetro é loadFactor .

capacidade - A capacidade deste conjunto de hash é 8. Ou seja, pode armazenar 8 elementos.
loadFactor - O fator de carga deste conjunto de hash é 0,6. Isso significa que, sempre que nossa tabela de hash for preenchida em 60%, os elementos serão movidos para uma nova tabela de hash com o dobro do tamanho da tabela de hash original.

Capacidade e fator de carga padrão

É possível criar um conjunto de hash vinculado sem definir sua capacidade e fator de carga. Por exemplo,

// LinkedHashSet with default capacity and load factor
LinkedHashSet<Integer> numbers1 = new LinkedHashSet<>();

Por padrão,

a capacidade do conjunto de hash vinculado será de 16
o fator de carga será de 0,75

Criando LinkedHashSet de outras coleções

Aqui está como podemos criar um conjunto de hash vinculado contendo todos os elementos de outras coleções.

import java.util.LinkedHashSet;
import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        // Creating an arrayList of even numbers
        ArrayList<Integer> evenNumbers = new ArrayList<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("ArrayList: " + evenNumbers);

        // Creating a LinkedHashSet from an ArrayList
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
        System.out.println("LinkedHashSet: " + numbers);
    }
}

Saída

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

Métodos de LinkedHashSet

O LinkedHashSet class fornece métodos que nos permitem realizar várias operações no conjunto de hash vinculado.

Inserir elementos no LinkedHashSet

add() - insere o elemento especificado no conjunto de hash vinculado
addAll() - insere todos os elementos da coleção especificada no conjunto de hash vinculado

Por exemplo,

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> evenNumber = new LinkedHashSet<>();

        // Using add() method
        evenNumber.add(2);
        evenNumber.add(4);
        evenNumber.add(6);
        System.out.println("LinkedHashSet: " + evenNumber);

        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        
        // Using addAll() method
        numbers.addAll(evenNumber);
        numbers.add(5);
        System.out.println("New LinkedHashSet: " + numbers);
    }
}

Saída

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

Acessar elementos LinkedHashSet

Para acessar os elementos de um conjunto de hash vinculado, podemos usar o iterator() método. Para usar este método, devemos importar o java.util.Iterator pacote. 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);

        // Calling the iterator() method
        Iterator<Integer> iterate = numbers.iterator();

        System.out.print("LinkedHashSet using Iterator: ");

        // Accessing elements
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Saída

LinkedHashSet: [2, 5, 6]
LinkedHashSet using Iterator: 2, 5, 6,

Observação :

hasNext() retorna true se houver um próximo elemento no conjunto de hash vinculado
next() retorna o próximo elemento no conjunto de hash vinculado

Remover elementos do HashSet

remove() - remove o elemento especificado do conjunto de hash vinculado
removeAll() - remove todos os elementos do conjunto de hash vinculado

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);

        // Using the remove() method
        boolean value1 = numbers.remove(5);
        System.out.println("Is 5 removed? " + value1);

        boolean value2 = numbers.removeAll(numbers);
        System.out.println("Are all elements removed? " + value2);
    }
}

Saída

LinkedHashSet: [2, 5, 6]
Is 5 removed? true
Are all elements removed? true

Definir operações

Os vários métodos do LinkedHashSet A classe também pode ser usada para executar várias operações de conjunto.

União de Conjuntos

Dois realizam a união entre dois conjuntos, podemos usar o addAll() método. 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);

        // Union of two set
        numbers.addAll(evenNumbers);
        System.out.println("Union is: " + numbers);
    }
}

Saída

LinkedHashSet1: [2, 4]
LinkedHashSet2: [1, 3]
Union is: [1, 3, 2, 4]

Intersecção de conjuntos

Para realizar a interseção entre dois conjuntos, podemos usar o retainAll() método. 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);

        // Intersection of two sets
        evenNumbers.retainAll(primeNumbers);
        System.out.println("Intersection is: " + evenNumbers);
    }
}

Saída

LinkedHashSet1: [2, 3]
LinkedHashSet2: [2, 4]
Intersection is: [2]

Diferença de conjuntos

Para calcular a diferença entre os dois conjuntos, podemos usar o removeAll() método. 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);

        // Difference between LinkedHashSet1 and LinkedHashSet2
        primeNumbers.removeAll(oddNumbers);
        System.out.println("Difference : " + primeNumbers);
    }
}

Saída

LinkedHashSet1: [2, 3, 5]
LinkedHashSet2: [1, 3, 5]
Difference: [2]

Subconjunto

Para verificar se um conjunto é um subconjunto de outro conjunto ou não, podemos usar o containsAll() método. 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);

        // Check if primeNumbers is a subset of numbers
        boolean result = numbers.containsAll(primeNumbers);
        System.out.println("Is LinkedHashSet2 is subset of LinkedHashSet1? " + result);
    }
}

Saída

LinkedHashSet1: [1, 2, 3, 4]
LinkedHashSet2: [2, 3]
Is LinkedHashSet2 is a subset of LinkedHashSet1? true

Outros métodos de LinkedHashSet

Método	Descrição
`clone()`	Cria uma cópia do `LinkedHashSet`
`contains()`	Pesquisa o `LinkedHashSet` para o elemento especificado e retorna um resultado booleano
`isEmpty()`	Verifica se o `LinkedHashSet` está vazio
`size()`	Retorna o tamanho do `LinkedHashSet`
`clear()`	Remove todos os elementos do `LinkedHashSet`

Para saber mais sobre LinkedHashSet métodos, visite Java LinkedHashSet (documentação oficial do Java).

LinkedHashSet vs. Conjunto de hash

Ambos LinkedHashSet e HashSet implementa o Set interface. No entanto, existem algumas diferenças entre eles.

LinkedHashSet mantém uma lista vinculada internamente. Por isso, mantém a ordem de inserção de seus elementos.
Os LinkedHashSet classe requer mais armazenamento do que HashSet . Isso ocorre porque LinkedHashSet mantém listas vinculadas internamente.
O desempenho de LinkedHashSet é mais lento que HashSet . É por causa das listas vinculadas presentes em LinkedHashSet .

LinkedHashSet vs. Conjunto de árvores

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

O TreeSet classe implementa o SortedSet interface. É por isso que os elementos em um conjunto de árvore são classificados. No entanto, o LinkedHashSet class mantém apenas a ordem de inserção de seus elementos.
Um TreeSet geralmente é mais lento que um LinkedHashSet . É porque sempre que um elemento é adicionado a um TreeSet , ele deve realizar a operação de classificação.
LinkedHashSet permite a inserção de valores nulos. No entanto, não podemos inserir um valor nulo em TreeSet .

Java EnumSet Interface Java SortedSet

Java