Classe Java HashSet

Neste tutorial, vamos aprender sobre a classe HashSet do Java. Vamos aprender diferentes métodos e operações de coleção de hash com exemplos.

A classe HashSet do Java Collections Framework fornece funcionalidades da estrutura de tabela de dispersão.

que implementaInterface Set.

Criar uma coleção de hash

Para criar uma coleção de hash, precisamos importar o pacote java.util.HashSet.

Depois de importar o pacote, você pode criar uma coleção de hash no Java.

//com8uma capacidade e 0.75HashSet com fator de carga
HashSet<Integer> numbers = new HashSet<>(8, 0.75);

Aqui, criamos uma coleção de hash chamada numbers.

Atenção, a nova parte HashSet<>(8, 0.75) Aqui, o primeiro parâmetro éCapacidadee o segundo parâmetro éFator de carga.

• capacity -A capacidade dessa coleção de hash é8Isso significa que pode armazenar8elementos.

• loadFactor - O fator de carga dessa coleção de hash é 0.6Isso significa que, desde que nossa coleção de hash esteja preenchida60%, os elementos serão movidos para uma nova tabela de dispersão, cujo tamanho é o dobro do da tabela de dispersão original.

Capacidade e fator de carga padrão

É possível criar uma tabela de dispersão sem definir sua capacidade e fator de carga. Por exemplo,

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

Padrão,

• A capacidade do conjunto de hash será 16

• O fator de carga será 0.75

Métodos HashSet

A classe HashSet oferece várias métodos, que nos permitem executar várias operações no conjunto.

Inserir elemento no HashSet

• add() - Inserir o elemento especificado no conjunto

• addAll() - Inserir todos os elementos do conjunto especificado no conjunto

Por exemplo,

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

Resultados de Saída

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

Acessar elementos HashSet

Para acessar os elementos da HashSet, podemos usar o método iterator(). Para usar esse método, devemos importar o pacote java.util.Iterator. Por exemplo,

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

Resultados de Saída

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

Remover elemento

• remove() - Remover o elemento especificado do conjunto

• removeAll() - Remover todos os elementos do conjunto

Por exemplo,

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

Resultados de Saída

HashSet: [2,　5,　6]
Valor5Removido? true
Todos os elementos foram removidos? true

Métodos de operação de conjunto

Os vários métodos da classe HashSet também podem ser usados para executar várias operações de conjunto.

Set集合并集

união de conjunto Set

import java.util.HashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Para realizar a interseção entre dois conjuntos, podemos usar o método retainAll(). Por exemplo
　　　　　　　　HashSet<Integer> evenNumbers = new HashSet<>();2);
　　　　　　　　HashSet<Integer> evenNumbers = new HashSet<>();4);
　　　　　　　　System.out.println("HashSet1: "　+　System.out.println("Interseção: ",
　　　　　　　　HashSet<Integer> numbers = new HashSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("HashSet2: "　+　numbers);
　　　　　　　　//Para realizar a união entre dois conjuntos, podemos usar o método addAll(). Por exemplo
　　　　　　　　união de conjunto
　　　　　　　　numbers.addAll(evenNumbers);　+　numbers);
　　　　}
}

Resultados de Saída

HashSet1: [2,　4]
HashSet2: [1,　3]
System.out.println("União é: ",1,　2,　3,　4]

união é: [

interseção de conjunto Set

import java.util.HashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashSet<Integer> primeNumbers = new HashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("HashSet1: "　+　primeNumbers);
　　　　　　　　Para realizar a interseção entre dois conjuntos, podemos usar o método retainAll(). Por exemplo
　　　　　　　　HashSet<Integer> evenNumbers = new HashSet<>();2);
　　　　　　　　HashSet<Integer> evenNumbers = new HashSet<>();4);
　　　　　　　　System.out.println("HashSet2: "　+　System.out.println("Interseção: ",
　　　　　　　　//evenNumbers.add(
　　　　　　　　interseção do conjunto
　　　　　　　　evenNumbers.retainAll(primeNumbers);　+　System.out.println("Interseção: ",
　　　　}
}

Resultados de Saída

HashSet1: [2,　3]
HashSet2: [2,　4]
interseção: [2]

diferença de conjunto Set

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

import java.util.HashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashSet<Integer> primeNumbers = new HashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　primeNumbers.add(5);
　　　　　　　　System.out.println("HashSet1: "　+　primeNumbers);
　　　　　　　　HashSet<Integer> oddNumbers = new HashSet<>();
　　　　　　　　oddNumbers.add(1);
　　　　　　　　oddNumbers.add(3);
　　　　　　　　oddNumbers.add(5);
　　　　　　　　System.out.println("HashSet2: "　+　oddNumbers);
　　　　　　　　//HashSet1e HashSet2diferença entre os conjuntos
　　　　　　　　primeNumbers.removeAll(oddNumbers);
　　　　　　　　System.out.println("Diferença: ",　+　primeNumbers);
　　　　}
}

Resultados de Saída

HashSet1: [2,　3,　5]
HashSet2: [1,　3,　5]
diferença: [2]

subconjunto de conjunto Set

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

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

Resultados de Saída

HashSet1: [1,　2,　3,　4]
HashSet2: [2,　3]
HashSet2É um HashSet1É um subconjunto? true

Outros métodos HashSet

Por que escolher HashSet?

No Java, se precisarmos acessar elementos aleatoriamente, geralmente usamos HashSet. Isso porque os elementos da tabela hash são acessados usando o hashCode.

O hashCode é uma identificação única que ajuda a identificar os elementos da tabela de dispersão.

HashSet não pode conter elementos repetidos. Portanto, cada elemento do conjunto de hash tem um hashCode único.

Atenção: HashSet não é sincronizado. Isso significa que se múltiplas threads acessarem o conjunto de hash ao mesmo tempo e uma dessas threads modificar o conjunto de hash, então, deve ser sincronizado externamente.