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).
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 è:
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:
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:
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);
}
}
L'output del programma è:
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);
}
}
L'output del programma è qui: