Java LinkedHashSet

In questo tutorial, impareremo con esempi la classe LinkedHashSet di Java e i suoi metodi.

La classe LinkedHashSet della Java Collection Framework fornisce le funzionalità di tabella hash e elenco collegato.

ImplementaInterfaccia Set.

Gli elementi di HashSet sono memorizzati in modo simile aHashSetnella tabella hash.

Ma HashSet mantiene internamente una doppia lista per tutti i suoi elementi. La lista definisce l'ordine di inserimento degli elementi nella tabella hash.

Creare una HashSet

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

Dopo aver importato il pacchetto, puoi creare HashSet in Java.

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

Qui, abbiamo creato una HashSet di nomi chiamata numbers.

Attenzione, nella dichiarazione new HashSet<>(8, 0.75). Qui, il primo parametro èCapacità，il secondo parametro èFattore di carico.

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

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

Capacità predefinita e fattore di carico

Puoi creare una HashSet senza definire la sua capacità e il fattore di carico. Ad esempio,

//HaSet con capacità predefinita e fattore di carico
LinkedHashSet<Integer> numbers1 = new LinkedHashSet<>();

Di default,

• La capacità dell'insieme hash linkato sarà 16

• Il fattore di carico sarà 0.75

Creare LinkedHashSet da altri insiemi

Ecco come possiamo creare un insieme hash linkato che contiene tutti gli elementi di altri insiemi.

import java.util.LinkedHashSet;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Creare arrayList di numeri pari
　　　　　　　　ArrayList<Integer> evenNumbers = new ArrayList<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("ArrayList: " + evenNumbers);
　　　　　　　　//Creare LinkedHashSet da ArrayList
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
　　　　　　　　System.out.println("LinkedHashSet: " + numbers);
　　　　}
}

Risultato di output

ArrayList: [2, 4]
LinkedHashSet: [2, 4]

Metodi di LinkedHashSet

La classe LinkedHashSet fornisce vari metodi per eseguire diverse operazioni sull'insieme hash della coda.

Inserire l'elemento nel LinkedHashSet

• add() - Inserisce l'elemento specificato nell'insieme hash della coda

• addAll() - Inserisce tutti gli elementi dell'insieme specificato nell'insieme hash della coda

Ad esempio,

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

Risultato di output

LinkedHashSet: [2, 4, 6]
Nuovo LinkedHashSet: [2, 4, 6, 5]

Accedere agli elementi di LinkedHashSet

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

import java.util.LinkedHashSet;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("LinkedHashSet: " + numbers);
　　　　　　　　//Chiamata al metodo iterator()
　　　　　　　　Iterator<Integer> iterate = numbers.iterator();
　　　　　　　　System.out.print("Utilizza LinkedHashSet con Iterator: ");
　　　　　　　　//Accedi agli elementi
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Risultato di output

LinkedHashSet: [2, 5, 6]
Utilizza LinkedHashSet con Iterator: 2, 5, 6,

Attenzione:

• hasNext() restituisce true se nella hash table collegata esiste un elemento successivo

• next() restituisce l'elemento successivo nella hash table collegata

Elimina l'elemento dal HashSet

• remove() - Elimina l'elemento specificato dalla hash table della coda

• removeAll() - Elimina tutti gli elementi dalla hash table della coda

Ad esempio,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("LinkedHashSet: " + numbers);
　　　　　　　　//Utilizza il metodo remove()
　　　　　　　　boolean value1 = numbers.remove(5);
　　　　　　　　System.out.println("Eliminato il numero 5? " + value1);
　　　　　　　　boolean value2 = numbers.removeAll(numbers);
　　　　　　　　System.out.println("Sono stati eliminati tutti gli elementi? " + value2);
　　　　}
}

Risultato di output

LinkedHashSet: [2, 5, 6]
Eliminato il numero 5? true
Sono stati eliminati tutti gli elementi? true

Metodi di operazione LinkedHashSet

Le varie metodologie della classe LinkedHashSet possono essere utilizzate per eseguire vari operazioni di Set.

Intersezione

Eseguiamo l'intersezione tra due insiemi utilizzando il metodo addAll(). Ad esempio,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet1: " + evenNumbers);
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet2: " + numbers);
　　　　　　　　//Unione tra due insiemi
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("Unione: " + numbers);
　　　　}
}

Risultato di output

LinkedHashSet1: [2, 4]
LinkedHashSet2: [1, 3]
Unione: [1, 3, 2, 4]

Intersezione

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

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet1: " + primeNumbers);
　　　　　　　　LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet2: " + evenNumbers);
　　　　　　　　//Intersezione degli insiemi
　　　　　　　　evenNumbers.retainAll(primeNumbers);
　　　　　　　　System.out.println("Intersezione degli insiemi: " + evenNumbers);
　　　　}
}

Risultato di output

LinkedHashSet1: [2, 3]
LinkedHashSet2: [2, 4]
Intersezione degli insiemi: [2]

Differenza

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

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　primeNumbers.add(5);
　　　　　　　　System.out.println("LinkedHashSet1: " + primeNumbers);
　　　　　　　　LinkedHashSet<Integer> oddNumbers = new LinkedHashSet<>();
　　　　　　　　oddNumbers.add(1);
　　　　　　　　oddNumbers.add(3);
　　　　　　　　oddNumbers.add(5);
　　　　　　　　System.out.println("LinkedHashSet2: " + oddNumbers);
　　　　　　　　//Differenza tra LinkedHashSet1 e LinkedHashSet2
　　　　　　　　primeNumbers.removeAll(oddNumbers);
　　　　　　　　System.out.println("Differenza: " + primeNumbers);
　　　　}
}

Risultato di output

LinkedHashSet1: [2, 3, 5]
LinkedHashSet2: [1, 3, 5]
Differenza: [2]

sottoinsieme

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

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　numbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet1: " + numbers);
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet2: " + primeNumbers);
　　　　　　　　//Controllare se primeNumbers è un sottoinsieme di numbers
　　　　　　　　boolean result = numbers.containsAll(primeNumbers);
　　　　　　　　System.out.println("LinkedHashSet2 è un sottoinsieme di LinkedHashSet1? " + result);
　　　　}
}

Risultato di output

LinkedHashSet1: [1, 2, 3, 4]
LinkedHashSet2: [2, 3]
LinkedHashSet2 è un sottoinsieme di LinkedHashSet1? true

Altri metodi di LinkedHashSet

La differenza tra LinkedHashSet e HashSet

LinkedHashSet e HashSet entrambi implementano l'interfaccia Set. Ma ci sono alcune differenze tra loro.

• LinkedHashSet mantiene internamente una coda. Pertanto, mantiene l'ordine di inserimento dei suoi elementi.

• LinkedHashSet richiede più spazio di archiviazione rispetto a HashSet. Questo è perché LinkedHashSet mantiene internamente una coda.

• La performance di LinkedHashSet è più lenta rispetto a HashSet. Questo è perché esiste una coda in LinkedHashSet.

Differenze tra LinkedHashSet e TreeSet

Di seguito sono riportate le principali differenze tra LinkedHashSet e TreeSet:

• La classe TreeSet implementa l'interfaccia SortedSet. Ecco perché gli elementi nella raccolta ad albero sono ordinati. Tuttavia, la classe LinkedHashSet mantiene solo l'ordine di inserimento dei suoi elementi.

• TreeSet è generalmente più lento di LinkedHashSet. Questo è perché ogni volta che si aggiunge un elemento a TreeSet, deve eseguire l'operazione di ordinamento.

• LinkedHashSet permette l'inserimento di valori nulli. Tuttavia, non possiamo inserire valori nulli in TreeSet.