Classe Java HashSet
Classe Java HashSet
Neste tutorial, aprenderemos sobre a classe Java HashSet. Aprenderemos sobre diferentes métodos e operações de conjuntos de hash com a ajuda de exemplos.
O
HashSet A classe da estrutura Java Collections fornece as funcionalidades da estrutura de dados da tabela de hash. Ele implementa a interface Set.
Criando um HashSet
Para criar um conjunto de hash, devemos importar o
java.util.HashSet pacote primeiro. Depois de importar o pacote, veja como podemos criar conjuntos de hash em Java.
// HashSet with 8 capacity and 0.75 load factor
HashSet<Integer> numbers = new HashSet<>(8, 0.75);
Aqui, criamos um conjunto de hash chamado
numbers . Observe, a parte nova
HashSet<>(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 nosso conjunto de hash é preenchido em 60%, os elementos sã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 uma tabela de hash sem definir sua capacidade e fator de carga. Por exemplo,
// HashSet with default capacity and load factor
HashSet<Integer> numbers1 = new HashSet<>();
Por padrão,
- a capacidade do conjunto de hash será de 16
- o fator de carga será de 0,75
Métodos de HashSet
O
HashSet classe fornece vários métodos que nos permitem realizar várias operações no conjunto. Inserir Elementos no HashSet
add()- insere o elemento especificado no conjuntoaddAll()- insere todos os elementos da coleção especificada no conjunto
Por exemplo,
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> evenNumber = new HashSet<>();
// Using add() method
evenNumber.add(2);
evenNumber.add(4);
evenNumber.add(6);
System.out.println("HashSet: " + evenNumber);
HashSet<Integer> numbers = new HashSet<>();
// Using addAll() method
numbers.addAll(evenNumber);
numbers.add(5);
System.out.println("New HashSet: " + numbers);
}
}
Saída
HashSet: [2, 4, 6] New HashSet: [2, 4, 5, 6]
Acessar elementos do conjunto de hash
Para acessar os elementos de um conjunto de hash, podemos usar o
iterator() método. Para usar este método, devemos importar o java.util.Iterator pacote. 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);
// Calling iterator() method
Iterator<Integer> iterate = numbers.iterator();
System.out.print("HashSet using Iterator: ");
// Accessing elements
while(iterate.hasNext()) {
System.out.print(iterate.next());
System.out.print(", ");
}
}
}
Saída
HashSet: [2, 5, 6] HashSet using Iterator: 2, 5, 6,
Remover elementos
remove()- remove o elemento especificado do conjuntoremoveAll()- remove 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);
// Using 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
HashSet: [2, 5, 6] Is 5 removed? true Are all elements removed? true
Definir operações
Os vários métodos do
HashSet A classe também pode ser usada para executar várias operações de conjunto. União de Conjuntos
Para realizar a união entre dois conjuntos, podemos usar o
addAll() método. Por exemplo,
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> evenNumbers = new HashSet<>();
evenNumbers.add(2);
evenNumbers.add(4);
System.out.println("HashSet1: " + evenNumbers);
HashSet<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(3);
System.out.println("HashSet2: " + numbers);
// Union of two set
numbers.addAll(evenNumbers);
System.out.println("Union is: " + numbers);
}
}
Saída
HashSet1: [2, 4] HashSet2: [1, 3] Union is: [1, 2, 3, 4]
Intersecção de conjuntos
Para realizar a interseção entre dois conjuntos, podemos usar o
retainAll() método. 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);
System.out.println("HashSet1: " + primeNumbers);
HashSet<Integer> evenNumbers = new HashSet<>();
evenNumbers.add(2);
evenNumbers.add(4);
System.out.println("HashSet2: " + evenNumbers);
// Intersection of two sets
evenNumbers.retainAll(primeNumbers);
System.out.println("Intersection is: " + evenNumbers);
}
}
Saída
HashSet1: [2, 3] HashSet2: [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.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);
// Difference between HashSet1 and HashSet2
primeNumbers.removeAll(oddNumbers);
System.out.println("Difference : " + primeNumbers);
}
}
Saída
HashSet1: [2, 3, 5] HashSet2: [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.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);
// Check if primeNumbers is a subset of numbers
boolean result = numbers.containsAll(primeNumbers);
System.out.println("Is HashSet2 is subset of HashSet1? " + result);
}
}
Saída
HashSet1: [1, 2, 3, 4] HashSet2: [2, 3] Is HashSet2 is a subset of HashSet1? true
Outros métodos de HashSet
| Método | Descrição |
|---|---|
clone() | Cria uma cópia do HashSet |
contains() | Pesquisa o HashSet para o elemento especificado e retorna um resultado booleano |
isEmpty() | Verifica se o HashSet está vazio |
size() | Retorna o tamanho do HashSet |
clear() | Remove todos os elementos do HashSet |
Para saber mais sobre os métodos HashSet, visite Java HashSet (documentação oficial do Java).
Por que HashSet?
Em Java,
HashSet é comumente usado se tivermos que acessar elementos aleatoriamente. Isso ocorre porque os elementos em uma tabela de hash são acessados usando códigos de hash. O hashcode de um elemento é uma identidade exclusiva que ajuda a identificar o elemento em uma tabela de hash.
HashSet não pode conter elementos duplicados. Portanto, cada elemento do conjunto de hash possui um código de hash exclusivo. Observação: HashSet não está sincronizado. Isto é, se vários encadeamentos acessarem o conjunto de hash ao mesmo tempo e um dos encadeamentos modificar o conjunto de hash. Em seguida, deve ser sincronizado externamente.
Java