English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
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.
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
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]
La classe LinkedHashSet fornisce vari metodi per eseguire diverse operazioni sull'insieme hash della coda.
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]
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
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
Le varie metodologie della classe LinkedHashSet possono essere utilizzate per eseguire vari operazioni di Set.
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]
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]
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]
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
Metodo | Descrizione |
---|---|
clone() | Creare una copia del LinkedHashSet |
contains() | Cercare l'elemento specificato nel LinkedHashSet e restituire il risultato booleano |
isEmpty() | Controllare se il LinkedHashSet è vuoto |
size() | Restituire la dimensione del LinkedHashSet |
clear() | Eliminare tutti gli elementi dal LinkedHashSet |
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.
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.