Classe Java HashSet
Classe Java HashSet
Dans ce tutoriel, nous allons découvrir la classe Java HashSet. Nous découvrirons différentes méthodes et opérations d'ensemble de hachage à l'aide d'exemples.
Le HashSet La classe du framework Java Collections fournit les fonctionnalités de la structure de données de la table de hachage.
Il implémente l'interface Set.
Créer un HashSet
Afin de créer un ensemble de hachage, nous devons importer le java.util.HashSet paquet d'abord.
Une fois le package importé, voici comment créer des ensembles de hachage en Java.
// HashSet with 8 capacity and 0.75 load factor
HashSet<Integer> numbers = new HashSet<>(8, 0.75);
Ici, nous avons créé un ensemble de hachage nommé numbers .
Remarquez, la partie nouvelle HashSet<>(8, 0.75) . Ici, le premier paramètre est la capacité , et le deuxième paramètre est loadFactor .
- capacité - La capacité de cet ensemble de hachage est de 8. Cela signifie qu'il peut stocker 8 éléments.
- facteur de charge - Le facteur de charge de cet ensemble de hachage est de 0,6. Cela signifie que, chaque fois que notre jeu de hachage est rempli à 60 %, les éléments sont déplacés vers une nouvelle table de hachage de la taille du double de la table de hachage d'origine.
Capacité et facteur de charge par défaut
Il est possible de créer une table de hachage sans définir sa capacité et son facteur de charge. Par exemple,
// HashSet with default capacity and load factor
HashSet<Integer> numbers1 = new HashSet<>();
Par défaut,
- la capacité du jeu de hachage sera de 16
- le facteur de charge sera de 0,75
Méthodes de HashSet
Le HashSet La classe fournit diverses méthodes qui nous permettent d'effectuer diverses opérations sur l'ensemble.
Insérer des éléments dans HashSet
add()- insère l'élément spécifié dans l'ensembleaddAll()- insère tous les éléments de la collection spécifiée dans l'ensemble
Par exemple,
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);
}
}
Sortie
HashSet: [2, 4, 6] New HashSet: [2, 4, 5, 6]
Accéder aux éléments HashSet
Pour accéder aux éléments d'un hash set, on peut utiliser le iterator() méthode. Pour utiliser cette méthode, nous devons importer le java.util.Iterator forfait. Par exemple,
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(", ");
}
}
}
Sortie
HashSet: [2, 5, 6] HashSet using Iterator: 2, 5, 6,
Supprimer des éléments
remove()- supprime l'élément spécifié de l'ensembleremoveAll()- supprime tous les éléments de l'ensemble
Par exemple,
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);
}
}
Sortie
HashSet: [2, 5, 6] Is 5 removed? true Are all elements removed? true
Définir les opérations
Les différentes méthodes du HashSet La classe peut également être utilisée pour effectuer diverses opérations d'ensemble.
Union d'ensembles
Pour réaliser l'union entre deux ensembles, on peut utiliser le addAll() méthode. Par exemple,
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);
}
}
Sortie
HashSet1: [2, 4] HashSet2: [1, 3] Union is: [1, 2, 3, 4]
Intersection d'ensembles
Pour effectuer l'intersection entre deux ensembles, on peut utiliser le retainAll() méthode. Par exemple
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);
}
}
Sortie
HashSet1: [2, 3] HashSet2: [2, 4] Intersection is: [2]
Différence des ensembles
Pour calculer la différence entre les deux ensembles, nous pouvons utiliser le removeAll() méthode. Par exemple,
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);
}
}
Sortie
HashSet1: [2, 3, 5] HashSet2: [1, 3, 5] Difference: [2]
Sous-ensemble
Pour vérifier si un ensemble est un sous-ensemble d'un autre ensemble ou non, on peut utiliser le containsAll() méthode. Par exemple,
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);
}
}
Sortie
HashSet1: [1, 2, 3, 4] HashSet2: [2, 3] Is HashSet2 is a subset of HashSet1? true
Autres méthodes de HashSet
| Méthode | Description |
|---|---|
clone() | Crée une copie du HashSet |
contains() | Recherche le HashSet pour l'élément spécifié et renvoie un résultat booléen |
isEmpty() | Vérifie si le HashSet est vide |
size() | Renvoie la taille du HashSet |
clear() | Supprime tous les éléments du HashSet |
Pour en savoir plus sur les méthodes HashSet, visitez Java HashSet (documentation officielle de Java).
Pourquoi HashSet ?
En Java, HashSet est couramment utilisé si nous devons accéder à des éléments de manière aléatoire. C'est parce que les éléments d'une table de hachage sont accessibles à l'aide de codes de hachage.
Le hashcode d'un élément est une identité unique qui permet d'identifier l'élément dans une table de hachage.
HashSet ne peut pas contenir d'éléments en double. Par conséquent, chaque élément de l'ensemble de hachage a un code de hachage unique.
Remarque : HashSet n'est pas synchronisé. C'est-à-dire si plusieurs threads accèdent au jeu de hachage en même temps et que l'un des threads modifie le jeu de hachage. Ensuite, il doit être synchronisé en externe.
Java