O que é um HashSet?
HashSet é um tipo de dados embutido em Java e, em termos leigos, você pode dizer “HashSet é uma coleção não ordenada de elementos exclusivos”. Veja um exemplo básico:
- Ele cria uma coleção ( coleção significa uma única unidade de objetos, por exemplo: ArrayList, LinkedList, Vector etc) que usa uma tabela hash para armazenamento.
- Valores duplicados não são permitidos em um HashSet.
- Você pode inserir valores “nulos” em um HashSet.
- Nenhuma ordem de inserção é mantida. Portanto, se você deseja inserir itens em ordem, um HashSet será uma má escolha para seus requisitos.
- Se você deseja obter/recuperar um elemento em tempo constante (O(1)), um HashSet é uma das melhores abordagens que você pode adotar.
O que é o método HashSet.contains()?
HashSet.contains() é um método booleano para verificar se um item está presente em uma instância de HashSet ou não. Simplificando, se o conjunto contém o elemento desejado. Java.util.HashSet fornece uma implementação eficiente para ele. Deixe-nos mostrar como você pode usá-lo efetivamente para resolver suas dúvidas.contém () com inteiros
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
// Declare your hash set
HashSet digits = new HashSet();
digits.add(0);
digits.add(1);
digits.add(2);
digits.add(3);
digits.add(4);
digits.add(5);
digits.add(null);
System.out.println("All elements in hashset:\t" + digits);
// Try adding duplicates
digits.add(5);
digits.add(2);
System.out.println("After adding duplicates: \t" + digits);
System.out.println("\n-------Using Contains Method-------");
// Check out if the following digits exist in the hashset
System.out.println("digits.contains(0) : " + digits.contains(0));
System.out.println("digits.contains(2) : " + digits.contains(2));
System.out.println("digits.contains(3) : " + digits.contains(7));
System.out.println("digits.contains(null) : " + digits.contains(null));
}
}
Saída
Todos os elementos no hashset: [0, null, 1, 2, 3, 4, 5] Depois de adicionar duplicatas: [0, null, 1, 2, 3, 4, 5] -------Usando o método Contains- ------ digits.contains(0) : true digits.contains(2) : true digits.contains(3) : false digits.contains(null) : true
contém () com Strings
Dê uma olhada em outro exemplo de método contains() com Strings .
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
// Try working with another hash set of String type
HashSet rainbow = new HashSet();
// Adding elements into HashSet using add()
rainbow.add("Red");
rainbow.add("Orange");
rainbow.add("Yellow");
rainbow.add("Green");
rainbow.add("Blue");
rainbow.add("Indigo");
rainbow.add("Violet");
// Let's traverse the hashset
System.out.println("Traversing the rainbow:");
for (String i : rainbow){
System.out.println(i);
}
// Check out if rainbow contains this color or not
System.out.println("\n-------Using Contains Method-------");
System.out.println("rainbow.contains(\"Yellow\"): \t" + rainbow.contains("Yellow"));
System.out.println("rainbow.contains(\"White\"): \t" + rainbow.contains("White"));
System.out.println("rainbow.contains(\"Lavender\"): \t" + rainbow.contains("Lavender"));
System.out.println("rainbow.contains(\"Red\"): \t" + rainbow.contains("Red"));
// Remove a color from rainbow using remove()
rainbow.remove("Red");
// Now consume set contains() method again to check if it's still present
System.out.println("rainbow.contains(\"Red\"): \t" + rainbow.contains("Red"));
System.out.println("\nAfter removing Red: " + rainbow);
}
}
Saída
Atravessando o arco-íris: Vermelho Violeta Amarelo Azul Índigo Laranja Verde -------Usando o Método Contém------- rainbow.contains("Yellow"): true rainbow.contains("White"): false rainbow. contém("Lavanda"): falso arco-íris.contains("Vermelho"): verdadeiro arco-íris.contains("Vermelho"): falso Depois de remover Vermelho: [Violeta, Amarelo, Azul, Índigo, Laranja, Verde]
Como você pode ver, a ordem de saída é diferente da ordem de colocação dos elementos no Hashset.
GO TO FULL VERSION