hashset java tutorial with programming examples
Este tutorial explica o que é HashSet em Java, métodos HashSet, como implementar e iterar por meio dele e outros conceitos relacionados com a ajuda de exemplos de programação:
Um HashSet é uma coleção que armazena objetos. O HashSet em Java é implementado usando a classe ‘HashSet’ do pacote java.util.
Esta classe implementa uma interface de conjunto. Ele usa HashTable, que é uma instância de HashMap para armazenamento.
=> Dê uma olhada no guia para iniciantes em Java aqui.
O que você aprenderá:
Java HashSet
Algumas das características do HashSet são fornecidas abaixo:
- Implementa uma interface Set que possui HashTable como estrutura interna. HashTable, por sua vez, é uma instância de HashMap.
- Não preserva a ordem dos elementos. Os elementos são armazenados em ordem aleatória.
- HashSet não permite valores duplicados.
- Implementa uma interface clonável e serializável além da interface Set.
- Podemos ter valores nulos em HashSet.
Hierarquia da classe HashSet
A hierarquia da classe HashSet é fornecida abaixo:
Conforme mostrado na figura acima, a classe HashSet estende a classe AbstractSet que, por sua vez, implementa a interface Set. A interface set herda a interface Collection que, por sua vez, estende a interface Iterable.
A versão Java 8 introduziu um novo método ‘Spliterator’ em HashSet que cria um divisor fail-fast que executa a ligação tardia sobre os elementos do HashSet.
A declaração geral da classe HashSet é:
public class HashSet extends AbstractSet implementa Set,
Clonável, serializável
Importar HashSet
Podemos incluir a funcionalidade HashSet no programa usando a instrução de importação conforme mostrado abaixo:
import java.util.HashSet;
ou
import java.util. *;
Declare HashSet em Java
Podemos criar um objeto HashSet em Java conforme mostrado abaixo:
HashSet h = novo HashSet ();
A classe HashSet fornece os seguintes construtores para criar objetos.
Protótipo de construtor | Descrição | |
---|---|---|
retirar | Remoção booleana (objeto o) | Remove o elemento fornecido o do HashSet se ele fizer parte do HashSet. |
HashSet () | Construtor padrão para HashSet | |
HashSet (capacidade interna) | Constrói um objeto HashSet com a 'capacidade' fornecida. | |
HashSet (capacidade interna, fator de carga flutuante) | Constrói um objeto HashSet com a ‘capacidade’ e ‘loadFactor’ fornecidos. | |
HashSet (coleção c) | Constrói um objeto HashSet a partir da coleção fornecida. |
Conforme mostrado na tabela acima, além do construtor padrão, esta classe também fornece os construtores que usam capacidade e fator de carga e outra coleção como seus argumentos. Podemos criar os objetos desta classe usando qualquer um desses construtores.
Inicializar HashSet
O código Java a seguir mostra a declaração e a inicialização do objeto da classe HashSet. Neste programa, criamos um objeto de classe HashSet a partir de um ArrayList. Inicialmente, criamos e inicializamos ArrayList e, em seguida, usamos esta ArrayList para criar e inicializar um objeto HashSet.
import java.util.*; class Main{ public static void main(String args[]){ //declare and initialize ArrayList ArrayList<String> myList=new ArrayList<String>(); myList.add('Red'); myList.add('Green'); myList.add('Blue'); //Create a HashSet and provide ArrayList in its constructor HashSet<String> mySet=new HashSet(myList); mySet.add('Yellow'); //print the HashSet System.out.println('The HashSet contents:'); Iterator<String> i=mySet.iterator(); while(i.hasNext()) { System.out.print(i.next() + ' '); } } }
Resultado:
Como o HashSet funciona internamente em Java?
Internamente, ele é implementado usando um HashTable. HashTable é uma instância de HashMap. Mas HashMap é uma coleção de pares de valores-chave. Então, como armazenamos HashSet em um HashMap?
Os valores do objeto de HashSet são as chaves para o HashMap.
Exemplo de Java HashSet
Vamos ver um exemplo detalhado de HashSet em Java.
import java.util.*; class Main{ public static void main(String args[]){ //Create a HashSet and add elements to it HashSet<String> mySet=new HashSet<String>(); mySet.add('Blue'); mySet.add('Green'); mySet.add('Blue'); mySet.add('Green'); mySet.add('Red'); mySet.add('Brown'); mySet.add('Yellow'); //Iterate through the HashSet and print its elements System.out.println('HashSet contents:'); Iterator<String> itr=mySet.iterator(); while(itr.hasNext()){ System.out.print(itr.next() + ' '); } } }
Resultado:
Aqui, usamos o construtor padrão para criar um objeto HashSet. Então, usando o método add, adicionamos elementos (cores) ao HashSet. Em seguida, usamos um iterador para percorrer o HashSet e imprimir o conteúdo.
HashSet Iterator
Em Java, o HashSet pode ser percorrido ou iterado de duas maneiras, conforme discutido abaixo.
Sem usar o Iterator
Aqui, não definimos um iterador no HashSet. Em vez disso, usamos um loop forEach. O programa a seguir mostra o percurso do HashSet usando um loop forEach.
import java.util.HashSet; import java.util.Set; class Main{ public static void main(String[] args) { // Create a HashSet Set<String> cities_HashSet = new HashSet<String>(); //Initialize HashSet with elements cities_HashSet.add('Mumbai'); cities_HashSet.add('Delhi'); cities_HashSet.add('Pune'); cities_HashSet.add('Chennai'); cities_HashSet.add('Bangaluru'); //use foreach loop to iterate through the HashSet System.out.println('HashSet contents:'); for (String city : cities_HashSet) { System.out.print(city + ' '); } } }
Resultado:
Usando o Iterator
A próxima abordagem de iteração é usar um iterador. Aqui, definimos um iterador para a classe HashSet e depois o percorremos.
O programa a seguir mostra essa abordagem.
import java.util.HashSet; import java.util.Set; import java.util.Iterator; class Main{ public static void main(String[] args) { // Create a HashSet Set<String> cities_HashSet = new HashSet<String>(); //Initialize HashSet with elements cities_HashSet.add('Mumbai'); cities_HashSet.add('Delhi'); cities_HashSet.add('Pune'); cities_HashSet.add('Chennai'); cities_HashSet.add('Bangaluru'); //use iterator to iterate through the HashSet System.out.println('HashSet contents using Iterator:'); Iterator<String> iter = cities_HashSet.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } } }
Resultado:
Métodos HashSet / API
A tabela a seguir mostra os métodos fornecidos pela classe HashSet. Fornecemos o protótipo e a descrição de cada método. Como visto, temos métodos para operações básicas como adicionar, remover, dimensionar, etc., bem como outros métodos para verificar o conteúdo, vazio, iterador, divisor, etc.
Método | Protótipo de Método | Descrição |
---|---|---|
adicionar | Adição booleana (E e) | Adiciona o elemento e fornecido ao HashSet, se ainda não estiver presente. |
Claro | Vazio claro () | Limpa ou remove todos os elementos do HashSet |
clone | Clone de objeto () | É usado para retornar uma cópia superficial desta instância de HashSet: os próprios elementos não são clonados. |
contém | Boolean contém (objeto o) | Verifica se o HashSet contém o objeto fornecido o e retorna verdadeiro se sim. |
está vazia | Boolean isEmpty () | Verifica se o HashSet está vazio. Retorna verdadeiro se sim. |
iterador | Iterator iterator () | Retorna um iterador que é usado para percorrer o HashSet. |
Tamanho | Tamanho interno () | Retorna o tamanho ou número de elementos presentes no HashSet. |
divisor | Divisor divisor () | Retorna o divisor fail-fast e late-binding para percorrer o HashSet. Este método foi introduzido no Java 8. |
Descrevemos os métodos fornecidos pela classe HashSet, agora vamos implementar um exemplo que demonstra os principais métodos da classe.
O programa Java a seguir demonstra os métodos desta classe.
import java.util.*; class Main{ public static void main(String args[]){ //create a HashSet and initialize it HashSet<String> colors_set=new HashSet<String>(); colors_set.add('Red'); colors_set.add('Green'); colors_set.add('Blue'); colors_set.add('Cyan'); System.out.println('Initial HashSet: '+colors_set); //remove() method => remove specified element colors_set.remove('Red'); System.out.println('
HashSet after remove(Red): '+colors_set); //declare and initialize another list HashSet<String> colors_hash=new HashSet<String>(); colors_hash.add('Yellow'); colors_hash.add('Magenta'); //addAll() method => add another HashSet to existing colors_set.addAll(colors_hash); System.out.println('
HashSet after add(colors_hash): '+colors_set); //removeAll() method => remove all elements specified in the argument colors_set.removeAll(colors_hash); System.out.println('
HashSet after removeAll(colors_hash) method: '+colors_set); //removeIf() => remove if given condition is fulfilled colors_set.removeIf(str->str.contains('Green')); System.out.println('
HashSet after removeIf(contains(Green)) method: '+colors_set); //clear() => delete all elements from the HashSet colors_set.clear(); System.out.println('
HashSet after clear() method: '+colors_set); } }
Resultado:
Converter HashSet em Array
Podemos usar o método toArray () de HashSet para converter o HashSet fornecido em um array. Observe que o tipo de dados e o tamanho do Array devem corresponder aos do HashSet.
O seguinte programa Java mostra essa conversão.
import java.util.HashSet; class Main{ public static void main(String[] args) { // Create a HashSet & inintialize it HashSet<String> num_HashSet = new HashSet<String>(); num_HashSet.add('One'); num_HashSet.add('Two'); num_HashSet.add('Three'); num_HashSet.add('Four'); // Print HashSet contents System.out.println('HashSet contents: '+ num_HashSet); // Declare an array with size = HashSet size String[] numArray = new String[num_HashSet.size()]; //use toArray method to convert HashSet to an array num_HashSet.toArray(numArray); // Print Array System.out.println('Array from HashSet: '); for(String val : numArray){ System.out.print(val + ' '); } } }
Resultado:
Classificar um HashSet
Podemos classificar um HashSet em Java. Os elementos HashSet não são classificados originalmente, pois não mantém a ordem dos elementos. Podemos seguir duas abordagens para classificar um HashSet em Java.
Usando o método Collections.sort ()
Nesta abordagem, convertemos o HashSet em uma lista. Em seguida, usamos o método Collections.sort () para classificar a lista. Esta lista é então impressa.
import java.util.*; public class Main { public static void main(String args[]) { // Create a HashSet & initialize it HashSet<String> cities_HashSet = new HashSet<String>(); cities_HashSet.add('Pune'); cities_HashSet.add('Mumbai'); cities_HashSet.add('Bangaluru'); cities_HashSet.add('Hyderabad'); System.out.println('Original HashSet: ' + cities_HashSet); // Convert HashSet to ArrayList List<String> cities_list = new ArrayList<String>(cities_HashSet); // Use Collections.sort () method to sort the list Collections.sort(cities_list); // Print the Sorted ArrayList (HashSet) System.out.println('Sorted HashSet:'+ cities_list); } }
Resultado:
melhor limpador de computador para windows 10
Convertendo HashSet em TreeSet
Usando essa abordagem, convertemos o HashSet em TreeSet. TreeSet mantém a ordem dos elementos. Portanto, quando o HashSet é convertido para TreeSet, os elementos são colocados em ordem.
O programa Java a seguir mostra essa conversão, classificando assim o HashSet.
import java.util.*; public class Main { public static void main(String args[]) { // Create and initialize a HashSet HashSet<String> cities_HashSet = new HashSet<String>(); cities_HashSet.add('Pune'); cities_HashSet.add('Mumbai'); cities_HashSet.add('Bangaluru'); cities_HashSet.add('Hyderabad'); System.out.println('Original HashSet:'+ cities_HashSet); // Sort HashSet using TreeSet TreeSet<String> treeSet = new TreeSet<String>(cities_HashSet); // Print the sorted HashSet System.out.println('HashSet sorted using using TreeSet:' + treeSet); } }
Resultado:
Vamos agora discutir algumas das diferenças entre HashSet e HashMap. Também discutiremos as diferenças entre HashSet e TreeSet.
HashSet Vs HashMap
A tabela a seguir mostra as principais diferenças entre HashSet e HashMap.
HashSet | HashMap |
---|---|
Os objetos são adicionados usando o método Add (). | HashMap usa o método put () para adicionar pares de valores-chave. |
Interface do conjunto de implementos. | Interface do Mapa de Implementos. |
Armazena objetos de um tipo específico. | Armazene pares de valores-chave de dados. |
Não permite valores duplicados de objetos. | Permite valores duplicados, mas não chaves duplicadas. |
Pode ter um único valor nulo. | Permite uma única chave nula e vários valores nulos. |
Usa internamente o objeto HashMap para armazenar dados. | Usa a técnica de hashing para armazenar dados. |
É mais lento quando comparado ao HashMap. | HashMap é mais rápido. |
HashSet Vs TreeSet
A seguir estão listadas as diferenças entre HashSet e TreeSet.
HashSet | TreeSet |
---|---|
Tem funcionalidade limitada. | Fornece muitas funções que oferecem várias operações e torna mais fácil usar o Treeset do que o HashSet. |
Não mantém a ordenação dos elementos. Armazena objetos em ordem aleatória. | Mantém a ordem natural dos elementos. |
Ele permite valores nulos. | Não pode ter valores nulos. |
Oferece melhor desempenho, pois leva um tempo constante para as operações básicas. | Oferece custo log n tempo para operações básicas. |
Muito mais rápido do que o Treeset. | Treeset é mais lento. |
Implementado internamente usando HashMap. | Treeset é implementado internamente usando Treemap navegável. |
Usa o método equals () para comparação. | Usa o método compareTo () para comparação. |
perguntas frequentes
P # 1) Como o HashSet funciona em Java?
Responda: HashSet em Java usa HashMap para armazenar o objeto. Um objeto HashMap é criado quando um objeto HashSet é criado. Os elementos ou objetos inseridos no HashSet são armazenados como chaves no HashMap.
P # 2) O HashSet é pedido em Java?
Responda: Não, não é pedido em Java. Ele armazena os elementos em ordem aleatória.
P # 3) O HashSet permite nulos?
Responda: sim, permite um único valor nulo. Isso significa que apenas um único elemento ou objeto pode ser nulo e não todos.
P # 4) Por que o HashSet é usado em Java?
Responda: É usado para armazenar pares de valores-chave em Java. É semelhante a HashTable, exceto que HashSet não está sincronizado e, ao contrário de HashTable, permite valores nulos e uma única chave nula. HashSet não é ordenado e pode ser usado para armazenar objetos não ordenados ou quando a ordem dos objetos não é necessária.
P # 5) O HashSet está sincronizado em Java?
Responda: O HashSet não está sincronizado em Java. Além disso, não é seguro para threads. Mas podemos torná-lo sincronizado usando o método synchronizedSet ().
Conclusão
HashSet é uma coleção que contém objetos que estão em ordem aleatória. A classe HashSet que implementa HashSet em Java usa internamente HashTable que implementa HashMap.
Vimos a declaração e inicialização de HashSet junto com os métodos fornecidos pela classe HashSet.
=> Leia a série de treinamento Easy Java.
Leitura recomendada
- Java Double - Tutorial com exemplos de programação
- Tutorial de Java Float com exemplos de programação
- Java Reverse String: Tutorial com exemplos de programação
- TreeSet em Java: Tutorial com exemplos de programação
- Tutorial de JAVA para iniciantes: mais de 100 tutoriais práticos em vídeo Java
- Java String contains () Tutorial de método com exemplos
- TreeMap em Java - Tutorial com exemplos de TreeMap em Java
- Jagged Array In Java - Tutorial com exemplos