Set Java

Set è un'interfaccia in Java Collection Framework. È possibile utilizzare Java Set per implementare raccolte non ordinate con elementi univoci. In questo articolo, esamineremo questa interfaccia e le sue implementazioni nel linguaggio Java, i metodi per lavorare con un set e forniremo anche alcuni esempi.

Cos'è JavaSet

Set è un'interfaccia di Java Collection Framework, ma Set non è una raccolta ordinata, a differenza di List . Ciò significa che gli elementi Java Set vengono conservati senza un ordine particolare. Quindi non c'è alcun controllo sulla posizione in cui è possibile inserire un elemento. Inoltre non è possibile accedere agli elementi tramite il loro indice. Matematicamente, un set è una raccolta di elementi unici. In realtà, questa è una raccolta non ordinata (raccolta non ordinata), in cui non è possibile memorizzare elementi identici. Se aggiungi intenzionalmente un elemento duplicato a un Set , questa azione verrà ignorata e il Set non cambierà. Tuttavia è consentito memorizzare un elemento nullo in esso.

Imposta implementazioni

Java Set è un'interfaccia, quindi è necessario utilizzare una delle sue implementazioni per creare oggetti. Questi sono HashSet , TreeSet e LinkedHashSet . In Set s, ogni elemento è memorizzato in una sola istanza e diverse implementazioni di Set utilizzano un ordine diverso per la memorizzazione degli elementi. In un HashSet , l'ordine degli elementi è determinato da un algoritmo complesso. Se l'ordine di archiviazione è importante per te, usa un contenitore TreeSet , che memorizza gli oggetti ordinati in ordine crescente in ordine di confronto o un LinkedHashSet, che memorizza gli elementi in ordine aggiuntivo. I set vengono spesso utilizzati per il test di appartenenza in modo da poter verificare facilmente se un oggetto appartiene a un determinato set, quindi in pratica viene solitamente scelta un'implementazione HashSet ottimizzata per la ricerca rapida. HashSet è una raccolta che utilizza i propri valori hash restituiti dal metodo hashCode() per memorizzare gli elementi internamente. Cioè, all'interno di HashSet<E> , viene memorizzato l' oggetto HashMap<E, Object> , che memorizza i valori di HashSet come chiavi. L'utilizzo di codici hash consente di cercare, aggiungere e rimuovere rapidamente elementi da un Set . LinkedHashSet è un HashSetche memorizza anche gli elementi in un elenco collegato. Un normale HashSet non mantiene l'ordine degli elementi. In primo luogo, ufficialmente semplicemente non esiste e, in secondo luogo, anche l'ordine interno può cambiare drasticamente quando viene aggiunto un solo elemento. E puoi ottenere un iteratore da LinkedHashSet e usarlo per esaminare tutti gli elementi nell'ordine esatto in cui sono stati aggiunti a LinkedHashSet . Non spesso, ma a volte può essere molto necessario. Un TreeSet è una raccolta che memorizza gli elementi come un albero ordinato per valore. All'interno di TreeSet<E> c'è una TreeMap<E, Object> che memorizza tutti questi valori. E questa TreeMaputilizza un albero binario bilanciato rosso-nero per memorizzare gli elementi. Pertanto, ha operazioni add() , remove() , contains() molto veloci.

Crea un oggetto insieme

Per creare un Set Object puoi usare uno dei seguenti form:

Set<Integer> intSet = new HashSet<>();
Set<String> vSet = new HashSet<>();
Set mySet = new LinkedHashSet();
HashSet<String> myHashset = new HashSet<>();

Ecco un semplice esempio, in cui creiamo 2 Set s, HashSet e LinkedHashSet e aggiungiamo in ciascuno 5 elementi. Possiamo usare il metodo add() per questo.

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

public class HashSetTest {
    public static void main(String[] args) {
        Set mySet = new HashSet();
        Set mySet2 = new LinkedHashSet();
//adding some string elements
        mySet.add("Stuart");
        mySet.add("Alex");
        mySet.add("Johnny");
        mySet.add("Igor");
        mySet.add("Bel");
        System.out.println(mySet);
        mySet2.add("Stuart");
        mySet2.add("Alex");
        mySet2.add("Johnny");
        mySet2.add("Igor");
        mySet2.add("Bel");
        System.out.println(mySet2);
    }
}

Ecco l'output del programma: Come accennato in precedenza, HashSet non mantiene l'ordine degli elementi, ma LinkedHashSet lo fa. È stato LinkedHashSet a fornirci gli elementi nell'ordine in cui li abbiamo scritti nel set.

Metodi Java Set

Ecco alcuni dei metodi importanti di Java Set :

• booleano add(E e) . Aggiunge l'elemento specificato all'insieme se non è già presente (operazione facoltativa).

• boolean remove(Oggetto o) . Rimuove l'elemento specificato da questo set se è presente (operazione facoltativa).

• boolean removeAll(Raccolta c) . Rimuove da questo set tutti i relativi elementi contenuti nella raccolta specificata (operazione facoltativa).

• boolean retainAll(Raccolta c) . Mantiene solo gli elementi di questo set contenuti nella raccolta specificata (operazione facoltativa).

• vuoto chiaro() . Rimuove tutti gli elementi dall'insieme.

• Iteratore iteratore() . Restituisce un iteratore sugli elementi in questo set.

• dimensione intera() . viene utilizzato per ottenere il numero di elementi nell'insieme.

• booleano isEmpty() . per verificare se Set è vuoto o meno.

• booleano contiene(Oggetto o) . Restituisce true se questo Set contiene l'elemento specificato.

• Iteratore iteratore() . Restituisce un iteratore sugli elementi in questo set. Gli elementi vengono restituiti in nessun ordine particolare.

• Oggetto[] toArray() . Restituisce un array contenente tutti gli elementi di questo set. Se questo set fornisce garanzie sull'ordine in cui i suoi elementi vengono restituiti dal suo iteratore, questo metodo deve restituire gli elementi nello stesso ordine.

I metodi sono simili a quelli di ArrayList , tranne per il fatto che il metodo add(Object o) aggiunge un oggetto all'insieme solo se non è già presente. Il valore restituito dal metodo è true se l'oggetto è stato aggiunto, false in caso contrario. Ci sono anche alcuni metodi ereditati da Collection<> Interface: parallelStream() , removeIf() , stream() e forEach() metodo ereditato da java.lang.Iterable Interface.

Esempio di operazioni principali di Java Set

In questo esempio creiamo un array di stringhe e poi lo passiamo a mySet utilizzando l' operazione Arrays.asList . Quindi rimuoviamo un altro paio di elementi e ne aggiungiamo un altro paio. In questo caso, uno degli elementi dell'insieme esiste già: non verrà aggiunto. Proveremo anche le operazioni di controllo del vuoto isEmpty() , determinando la dimensione dell'insieme size() e cancellando l'insieme di tutti gli elementi clear() .

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class HashSetTest2 {
   public static void main(String[] args) {
       //creating a string Array with some names
       String [] friends =  {"Stuart", "Ivy", "Johnny", "Alex", "Igor", "Tanya"};
       //creating a new set and adding elements from string array into it
       Set<String> mySet = new HashSet<>(Arrays.asList(friends));
       System.out.println(mySet);
       //removing two elements from the set
       mySet.remove("Igor");
       mySet.remove("Stuart");

       System.out.println(mySet);

       //adding 2 new Elements into set
       mySet.add("Dasha");
       mySet.add("Alex"); //it's second Alex, can't be added
       System.out.println(mySet);
       //cheking the size of mySet
       int size = mySet.size();
       System.out.println("The quantity of set's elements = " + size);
       //Checking if the set is empty
       System.out.println("Is mySet empty? " + mySet.isEmpty());
       //checking if some elements are in set
       System.out.println("Is Igor in set? " + mySet.contains("Igor"));
       System.out.println("Is Johnny in set? "+ mySet.contains("Johnny"));
       //deleting all elements from the set
       mySet.clear();
       System.out.println("Is mySet empty now? " + mySet.isEmpty());

   }
}

L'output del programma è qui:

Esempio con LinkedHashSet e impostato su Array

Scriviamo un altro programma. In esso, creeremo un set basato su LinkedHashSet , vi aggiungeremo elementi e quindi convertiremo il set in un array.

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
   public class LinkedHashSet3 {
       public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("C");
           set.add("D");
           set.add("E");
           set.add("F");
           set.add("G");
           set.add("A");
           set.add("B");
           System.out.println(set);
           set.remove("F");// removing an element from our set
           set.remove("C sharp");//trying to remove element that isn't in set
           System.out.println(set.remove("C sharp"));
           System.out.println("Print our set with elements removed: ");
           System.out.println(set);

//set to array
           String strArray[] = set.toArray(new String[set.size()]);
           System.out.println("New Array from set: ");
           System.out.println(Arrays.toString(strArray));
           System.out.println(strArray[0]);

       }
   }

Ecco l'output del programma:

Imposta esempio con iteratore

Creiamo un set, poi lo stampiamo usando un iteratore, quindi rimuoviamo tutti i numeri pari da esso, usando anche un iteratore.

import java.util.*;

public class SetTest5
{
   public static void main(String[] args)
   {

       Set<Integer> mySet = new HashSe<>();
       for(int i = 0; i < 10; i++)
           mySet.add(i);

       Iterator iterator = mySet.iterator();

       //simple iteration
       while(iterator.hasNext()){
           int i = (int) iterator.next();
       }
       System.out.println(" " + mySet);

       //modification of mySet using iterator - removing all even numbers
       iterator = mySet.iterator();
       while(iterator.hasNext()){
           int x = (int) iterator.next();
           if(x%2 == 0) iterator.remove();
       }
       System.out.println(mySet);

       }
}

L'output del programma è qui:

Esempio con TreeSet

Se l'ordinamento è importante per te, usa l'implementazione TreeSet . In questo breve esempio, riempiremo il set con i nomi degli amici, come negli esempi precedenti. Tuttavia, in un TreeSet ordinato , gli elementi verranno immediatamente scritti in ordine ordinato. In questo caso, i nomi verranno visualizzati in ordine alfabetico.

import java.util.Set;
import java.util.TreeSet;
public class TreeSetTest {

   public static void main(String[] args) {

       Set mySet = new TreeSet<>();
       mySet.add("Stuart");
       mySet.add("Alex");
       mySet.add("Johnny");
       mySet.add("Igor");
       mySet.add("Bel");
       System.out.println(mySet);

   }

L'uscita è:

Brevi conclusioni

• L'interfaccia Java Set fa parte di Java Collections Framework.

• Classi implementate: AbstractSet , ConcurrentHashMap.KeySetView , ConcurrentSkipListSet , CopyOnWriteArraySet , EnumSet , HashSet , JobStateReasons , LinkedHashSet , TreeSet .

• Le implementazioni Set più popolari sono HashSet , LinkedHashSet e TreeSet .

• L'ordine degli elementi HashSet è determinato da un algoritmo complesso. Se l'ordine di archiviazione è importante per te, usa un contenitore TreeSet , che memorizza gli oggetti ordinati in ordine crescente in ordine di confronto, o un LinkedHashSet , che memorizza gli elementi in ordine aggiuntivo.

• Molto spesso, i set vengono utilizzati per testare l'appartenenza. Cioè, per verificare se un oggetto appartiene a un dato insieme in senso matematico. Quindi, più spesso di tutte le implementazioni di Set in pratica, viene solitamente scelto HashSet . Questa implementazione è ottimizzata per la ricerca rapida.

• Non puoi aggiungere elementi duplicati a un set, quindi puoi utilizzare le implementazioni dell'interfaccia Set per archiviare elementi univoci.

• Set consente di aggiungere un solo elemento nullo.

• Set non è un elenco e non supporta indici o posizioni dei suoi elementi.