Méthode HashSet contains() en Java

Qu'est-ce qu'un HashSet ?

HashSet est un type de données intégré à Java, et en termes simples, vous pouvez dire "HashSet est une collection non ordonnée d'éléments uniques". Jetez un oeil à un exemple de base: Fig 1: Une illustration montrant des exemples valides et invalides d'un HashSet (Avant d'aller plus loin, nous attendons de vous que vous connaissiez les termes hachage et tables de hachage .) HashSet étend ( étend signifie qu'une classe est héritée d'une autre classe) AbstractSet et implémente l'interface Set. Voici quelques points dont vous devez tenir compte avant de travailler avec les HashSets :

• Il crée une collection ( collection signifie une seule unité d'objets, par exemple : ArrayList, LinkedList, Vector, etc.) qui utilise une table de hachage pour le stockage.
• Les valeurs en double ne sont pas autorisées dans un HashSet.
• Vous pouvez insérer des valeurs "nulles" dans un HashSet.
• Aucun ordre d'insertion n'est conservé. Donc, si vous cherchez à insérer des éléments dans l'ordre, un HashSet sera un mauvais choix pour vos besoins.
• Si vous souhaitez obtenir/récupérer un élément en temps constant (O(1)) , un HashSet est l'une des meilleures approches que vous puissiez adopter.

Qu'est-ce que la méthode HashSet.contains() ?

HashSet.contains() est une méthode booléenne pour vérifier si un élément est présent ou non dans une instance de HashSet. Autrement dit, si l'ensemble contient l'élément souhaité. Java.util.HashSet en fournit une implémentation efficace. Laissez-nous vous montrer comment vous pouvez l'utiliser efficacement pour résoudre vos requêtes.

contient () avec des entiers

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

Sortir

contient () avec des chaînes

Jetez un œil à un autre exemple de méthode contains() avec 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);         
	}
}

Sortir Comme vous pouvez le voir, l'ordre de sortie est différent de l'ordre de mise des éléments dans le Hashset.

Conclusion

La méthode contains() pour HashSets est assez simple à utiliser. Cependant, en cas de confusion, vous pouvez toujours vous référer à ce message. Bon codage ! :)