Parlando della classe LinkedHashSet in Java, dobbiamo menzionare che implementa l' interfaccia Set . LinkedHashSet crea una raccolta che memorizza gli elementi in una tabella hash ma mantiene l'ordine di inserimento degli elementi a differenza della sua controparte HashSet .
Cosa è impostato in Java
Ricordiamo brevemente che l' interfaccia Set definisce un set (set). Estende Collection e definisce il comportamento delle raccolte che non consentono elementi duplicati. Pertanto, il metodo add() restituisce false se si tenta di aggiungere un elemento duplicato all'insieme. L'interfaccia non definisce alcun metodo aggiuntivo proprio. L' interfaccia Set si occupa dell'unicità degli oggetti memorizzati, l'unicità è determinata dall'implementazione del metodo equals() . Pertanto, se gli oggetti della classe creata verranno aggiunti a Set , è preferibile eseguire l'override del metodo equals() .
Classe LinkedHashSet
Prima di parlare della classe LinkedHashSet , dobbiamo menzionare il suo parente stretto, la classe HashSet . HashSet implementa l' interfaccia Set . Crea una raccolta che memorizza gli elementi in una tabella hash. Gli elementi di una tabella hash vengono archiviati come coppie chiave-valore. La chiave specifica la cella (o il segmento) in cui memorizzare il valore. Il contenuto della chiave viene utilizzato per determinare un valore univoco chiamato codice hash. Possiamo pensare a un codice hash come a un identificatore di oggetto, anche se non deve essere univoco. Questo codice hash funge anche da indice in cui vengono archiviati i dati associati alla chiave. La classe LinkedHashSet Java estende HashSet senza aggiungere nuovi metodi.LinkedHashSet ti consente di verificare rapidamente l'esistenza di una voce, proprio come HashSet , ma contiene un elenco ordinato all'interno. Ciò significa che memorizza l'ordine di inserimento degli elementi. In altre parole, LinkedHashSet mantiene un elenco collegato di elementi impostati nell'ordine in cui sono stati inseriti. Ciò consente l'iterazione ordinata dell'inserimento in un set. Ma questo fa sì che la classe LinkedHashSet esegua operazioni più lunghe della classe HashSet .
Caratteristiche importanti di LinkedHashSet
Possiamo memorizzare elementi univoci solo in un LinkedHashSet
LinketHashSet ci permette di estrarre gli elementi nello stesso ordine in cui li inseriamo
LinkedHashSet non è sincronizzato
LinkedHashSet consente di memorizzare elementi nulli
LinkedHashSet utilizza una tecnica di hashing per archiviare elementi in un indice specificato basato su un codice hash
Metodi LinkedHashSet
Oltre ai metodi ereditati dalle sue classi padre, HashSet definisce i seguenti metodi:
boolean add(Object o) aggiunge l'elemento specificato a questo set se non è già presente.
void clear() rimuove tutti gli elementi da questo insieme.
Object clone() restituisce una copia superficiale di questa istanza LinkedHashSet : gli elementi stessi non vengono clonati.
boolean contains(Object o) restituisce true se questo set contiene l'elemento specificato.
boolean isEmpty() restituisce true se questo set non contiene elementi.
Iterator iterator() restituisce un iteratore sugli elementi di questo insieme.
boolean remove(Object o) rimuove l'elemento specificato da questo insieme, se presente.
int size() restituisce il numero di elementi in questo insieme (il suo numero di elementi).
Semplici esempi di LinkedHashSetNell'esempio seguente mostriamo l'inizializzazione dell'oggetto
LinkedHashSet e l'utilizzo del metodo
add() per riempire il set.
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetEx1 {
public static void main(String[] args) {
//LinkedHashSet() Init
Set<String> set = new LinkedHashSet<>();
//adding elements to LinkedHashSet
set.add("Re"); //first added element
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");//last added element
System.out.println(set);
}
}
L'uscita è:
[Re, Do, Fa, Sol, La, Ti, Mi]
Come puoi vedere, gli elementi del nostro set sono apparsi nello stesso ordine in cui li abbiamo inseriti.
Esempio 2. Aggiunta di un duplicato in LinkedHashSet
Inseriamo nuovamente i nostri elementi
LinkedHashSet 7 con i nomi degli spartiti musicali e inseriamo un nuovo elemento uguale a uno degli elementi posizionati prima.
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetEx2 {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
set.add("Re");
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");
set.add("Sol");
System.out.println(set);
}
}
L'output del programma è qui:
[Re, Do, Fa, Sol, La, Ti, Mi]
L'output dell'esempio due è esattamente lo stesso del primo esempio. Non possiamo avere due elementi simili nella raccolta
LinkedHashSet . Quando proviamo a inserire il secondo, viene semplicemente ignorato.
Esempio 3. Rimozione di elementi da LinkedHashSet
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSet3 {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
set.add("Re");
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");
System.out.println(set);
set.remove("Fa");// removing an element from our set
set.remove("Score");//trying to remove element that isn't in set
System.out.println(set.remove("Score"));
System.out.println("Print our set without elements removed: ");
System.out.println(set);
set.clear();
System.out.println("Print out our set after clear command: ");
System.out.println(set);
}
}
L'output del programma è qui:
[Re, Do, Fa, Sol, La, Ti, Mi] false Stampa il nostro set senza elementi rimossi: [Re, Do, Sol, La, Ti, Mi] Stampa il nostro set dopo un chiaro comando: []
Come puoi vedere, il metodo
remove() applicato a un elemento inesistente non genera un errore del programma. Restituisce semplicemente
false se l'elemento non è stato rimosso e
true se l'elemento era nel
LinkedHashSet e quindi rimosso.
LinkedHashSet vs HashSet
Queste due classi sono parenti stretti. Tuttavia all'interno di
HashSet utilizza
HashMap per memorizzare oggetti mentre
LinkedHashSet utilizza
LinkedHashMap . Se non è necessario mantenere l'ordine di inserimento ma è necessario archiviare oggetti univoci, è più appropriato utilizzare
HashSet . Se devi mantenere l'ordine di inserimento degli elementi,
LinkedHashSet è la tua scelta. Le prestazioni di
LinkedHashSet sono un po' più lente di
HashSet perché
LinkedHashSet utilizza
LinkedList interno per mantenere l'ordine di inserimento degli elementi. Facciamo un esempio:
import java.util.*;
public class LinkedHashSetExample1 {
public static void main(String[] args) {
// while regular hash set orders its elements according to its hashcode stamps
Set<Integer> regularHashSet = new HashSet<>();
regularHashSet.add(7);
regularHashSet.add(3);
regularHashSet.add(5);
regularHashSet.add(65536);
regularHashSet.add(9);
// few duplicates
regularHashSet.add(5);
regularHashSet.add(7);
// next will print:
// > regularHashSet = [65536, 3, 5, 7, 9]
System.out.println("regularHashSet = " + regularHashSet);
// linked hash set keeps order of adding unchanged
Set<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(7);
linkedHashSet.add(3);
linkedHashSet.add(5);
linkedHashSet.add(65536);
linkedHashSet.add(9);
// few duplicates
linkedHashSet.add(5);
linkedHashSet.add(7);
// next will print:
// > linkedHashSet = [7, 3, 5, 65536, 9]
System.out.println("linkedHashSet = " + linkedHashSet);
}
}
Utilizzo di Java LinkedHashSet nelle applicazioni del mondo reale
Poiché
LinkedHashSet consente di verificare rapidamente l'esistenza di una voce e memorizza anche l'ordine, questa raccolta sembra essere abbastanza comoda per eliminare i duplicati da un elenco. O, ad esempio, risolvere problemi come l'ultimo oggetto visto di recente nella mia borsa. Oppure, ricordi un gioco del genere, Pokemon Go?
LinkedHashSet può memorizzare un elenco di Pokémon che hai incontrato e l'ordine in cui si sono imbattuti sul tuo cammino. In questo caso, i Pokémon "ripetuti" non verranno più aggiunti alla lista. O, ad esempio, un elenco di boss per livello che hai già incontrato in qualsiasi gioco con livelli. O la storia della scoperta dei corpi cosmici.
LinkedHashSetti consente di verificare rapidamente se un corpo spaziale è già nell'elenco o meno e, se non è presente, aggiungilo all'elenco. Facciamo un esempio di eliminazione dei duplicati.
import java.util.*;
class LinkedHashSetExample2 {
public static void main(String[] args) {
List<String> listWithDuplicates = List.of("some","elements","with", "few", "duplicates", "were", "here", "duplicates", "duplicates");
Set<String> linkedHashSet = new LinkedHashSet<>(listWithDuplicates);
List<String> listWithoutDuplicates = new ArrayList<>(linkedHashSet);
// next will print:
// > listWithDuplicates = [some, elements, with, few, duplicates, here, duplicates, duplicates]
System.out.println("listWithDuplicates = " + listWithDuplicates);
// next will print:
// > listWithoutDuplicates = [some, elements, with, few, duplicates, here]
System.out.println("listWithoutDuplicates = " + listWithoutDuplicates);
// -------------------------------------------------------------------------
// while using regular Hash Set will generally produces some unexpected order
Set<String> regularHashSet = new HashSet<>(listWithDuplicates);
// next will print:
// > linkedHashSet = [some, elements, with, few, duplicates, were, here]
System.out.println("linkedHashSet = " + linkedHashSet);
// next will print:
// > regularHashSet = [here, some, with, duplicates, were, elements, few]
System.out.println("regularHashSet = " + regularHashSet);
}
}
GO TO FULL VERSION