Classe Java HashSet

In questo tutorial, impareremo la classe HashSet di Java. Impareremo i diversi metodi e operazioni delle raccolte hash attraverso esempi.

La classe HashSet del framework Java Collections fornisce le funzionalità della struttura dati tabella hash.

ImplementaInterfaccia Set.

Creare una raccolta hash

Per creare raccolte hash, dobbiamo prima importare il pacchetto java.util.HashSet.

Dopo aver importato il pacchetto, è possibile creare raccolte hash in Java.

// HashSet con 8 capacità e 0.75 fattore di carico
HashSet<Integer> numbers = new HashSet<>(8, 0.75);

Qui, abbiamo creato una raccolta hash chiamata numbers.

Attenzione, la nuova parte HashSet<>(8, 0.75). Qui, il primo parametro èCapacità, e il secondo parametro èFattore di carico.

• capacity - La capacità di questa raccolta hash è 8. Questo significa che può memorizzare 8 elementi.

• loadFactor - Il fattore di carico di questa raccolta hash è 0.6. Questo significa che non appena la raccolta hash è stata riempita al 60%, gli elementi verranno spostati in una nuova tabella hash, la cui dimensione è il doppio della tabella hash originale.

Capacità predefinita e fattore di carico

È possibile creare una hash table senza definire la sua capacità e il fattore di carico. Ad esempio,

//HashSet con capacità e fattore di carico predefiniti
HashSet<Integer> numbers1 = new HashSet<>();

Di default,

• La capacità della hash set sarà 16

• Il fattore di carico sarà 0.75

Metodi della HashSet

La classe HashSet fornisce vari metodi che ci permettono di eseguire diverse operazioni sulla collection.

Inserire l'elemento nella HashSet

• add() - Inserisce l'elemento specificato nella collection

• addAll() - Inserisce tutti gli elementi di una collection specificata nella collection

ad esempio,

import java.util.HashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashSet<Integer> evenNumber = new HashSet<>();
　　　　　　　　//Utilizzo del metodo add()
　　　　　　　　evenNumber.add(2);
　　　　　　　　evenNumber.add(4);
　　　　　　　　evenNumber.add(6);
　　　　　　　　System.out.println("HashSet: " + evenNumber);
　　　　　　　　HashSet<Integer> numbers = new HashSet<>();
　　　　　　　　
　　　　　　　　//Utilizzo del metodo addAll()
　　　　　　　　numbers.addAll(evenNumber);
　　　　　　　　numbers.add(5);
　　　　　　　　System.out.println("Nuova HashSet: " + numbers);
　　　　}
}

Risultato di output

HashSet: [2, 4, 6]
Nuova HashSet: [2, 4, 5, 6]

Accedi agli elementi della HashSet

Per accedere agli elementi della hash set, possiamo utilizzare il metodo iterator(). Per utilizzare questo metodo, dobbiamo importare il pacchetto java.util.Iterator. Ad esempio,

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);
　　　　　　　　//Chiamata al metodo iterator()
　　　　　　　　Iterator<Integer> iterate = numbers.iterator();
　　　　　　　　System.out.print("HashSet utilizzando Iterator: ");
　　　　　　　　//Accedi all'elemento
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Risultato di output

HashSet: [2, 5, 6]
HashSet utilizzando Iterator: 2, 5, 6,

Rimuovere l'elemento

• remove() - Rimuove l'elemento specificato dalla集合

• removeAll() - Rimuove tutti gli elementi dalla集合

ad esempio,

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);
　　　　　　　　//Utilizzo del metodo remove()
　　　　　　　　boolean value1 = numbers.remove(5);
　　　　　　　　System.out.println("È stato rimosso il valore 5? " + value1);
　　　　　　　　boolean value2 = numbers.removeAll(numbers);
　　　　　　　　System.out.println("Sono stati rimossi tutti gli elementi? " + value2);
　　　　}
}

Risultato di output

HashSet: [2, 5, 6]
È stato rimosso il valore 5? true
Sono stati rimossi tutti gli elementi? true

Metodi di operazioni Set

I vari metodi della classe HashSet possono anche essere utilizzati per eseguire diverse operazioni di set.

Unione di insiemi Set

Per eseguire l'unione tra due insiemi, possiamo utilizzare il metodo addAll(). Ad esempio,

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);
　　　　　　　　//Unione degli insiemi
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("Unione è: " + numbers);
　　　　}
}

Risultato di output

HashSet1: [2, 4]
HashSet2: [1, 3]
Unione è: [1, 2, 3, 4]

Intersezione di insiemi Set

Per eseguire l'intersezione tra due insiemi, possiamo utilizzare il metodo retainAll(). Ad esempio,

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);
　　　　　　　　//Intersezione degli insiemi
　　　　　　　　evenNumbers.retainAll(primeNumbers);
　　　　　　　　System.out.println("Intersezione: " + evenNumbers);
　　　　}
}

Risultato di output

HashSet1: [2, 3]
HashSet2: [2, 4]
Intersezione: [2]

Differenza di insiemi Set

Per calcolare la differenza tra due insiemi, possiamo utilizzare il metodo removeAll(). Ad esempio,

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);
　　　　　　　　//Differenza tra HashSet1 e HashSet2
　　　　　　　　primeNumbers.removeAll(oddNumbers);
　　　　　　　　System.out.println("Differenza: " + primeNumbers);
　　　　}
}

Risultato di output

HashSet1: [2, 3, 5]
HashSet2: [1, 3, 5]
Differenza: [2]

Sottoinsieme di Set

Per controllare se un insieme è un sottoinsieme di un altro insieme, possiamo utilizzare il metodo containsAll(). Ad esempio,

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);
　　　　　　　　//Controlla se primeNumbers è un sottoinsieme di numbers
　　　　　　　　boolean result = numbers.containsAll(primeNumbers);
　　　　　　　　System.out.println("HashSet2 è un sottoinsieme di HashSet1? " + result);
　　　　}
}

Risultato di output

HashSet1: [1, 2, 3, 4]
HashSet2: [2, 3]
HashSet2 è un sottoinsieme di HashSet1? true

Altri metodi di HashSet

Perché scegliere HashSet?

In Java, se dobbiamo accedere casualmente agli elementi, di solito usiamo HashSet. Questo perché gli elementi dell'hashtable sono acceduti tramite il hashcode.

Il hashcode è un identificatore unico che aiuta a identificare gli elementi dell'hashtable.

HashSet non può contenere elementi duplicati. Pertanto, ogni elemento del set di hash ha un hashcode unico.

Attenzione: HashSet non è sincronizzato. Questo significa che se più thread accedono contemporaneamente a un set di hash e uno di loro modifica il set di hash, allora deve essere sincronizzato esternamente.