Java-sett

Set er et grensesnitt i Java Collection Framework. Du kan bruke Java Set til å implementere uordnede samlinger med unike elementer. I denne artikkelen skal vi se på dette grensesnittet og dets implementeringer i Java-språket, metoder for å jobbe med et sett, og også gi noen eksempler.

Hva er Java Set

Sett er et grensesnitt fra Java Collection Framework, men Set er ikke en ordnet samling, i motsetning til List . Det betyr at Java Set- elementer holdes uten en bestemt rekkefølge. Så det er ingen kontroll over posisjonen der du kan sette inn et element. Du kan heller ikke få tilgang til elementer etter deres indeks. Matematisk sett er et sett en samling unike elementer. Faktisk er dette en uordnet samling (uordnet samling), der identiske elementer ikke kan lagres. Hvis du med vilje legger til et duplikatelement i et sett , vil denne handlingen bli ignorert og settet vil ikke endres. Det er imidlertid tillatt å lagre ett null-element i det.

Angi implementeringer

Java Set er et grensesnitt, så du må bruke en av implementeringene for å lage objekter. Disse er HashSet , TreeSet og LinkedHashSet . I sett s er hvert element lagret i bare én forekomst, og forskjellige implementeringer av sett bruker en annen rekkefølge for lagring av elementer. I et HashSet bestemmes rekkefølgen av elementene av en kompleks algoritme. Hvis lagringsrekkefølge er viktig for deg, bruk en TreeSet- beholder, som lagrer objekter sortert i stigende rekkefølge i sammenligningsrekkefølge, eller et LinkedHashSet, som lagrer elementer i tilleggsrekkefølge. Sett brukes ofte til medlemskapstesting slik at man enkelt kan sjekke om et objekt tilhører et gitt sett, så i praksis velges vanligvis en HashSet- implementering som er optimalisert for raskt oppslag. HashSet er en samling som bruker hash-verdiene deres returnert av hashCode() -metoden for å lagre elementer internt. Det vil si at inne i HashSet<E> lagres HashMap<E, Object>-objektet, som lagrer verdiene til HashSet som nøkler . Ved å bruke hash-koder kan du raskt søke, legge til og fjerne elementer fra et sett . LinkedHashSet er et HashSetsom også lagrer elementer i en koblet liste. Et normalt HashSet opprettholder ikke elementrekkefølge. For det første eksisterer den rett og slett ikke offisielt, og for det andre kan til og med den interne rekkefølgen endres dramatisk når bare ett element legges til. Og du kan få en iterator fra LinkedHashSet og bruke den til å gå gjennom alle elementene i den nøyaktige rekkefølgen de ble lagt til i LinkedHashSet . Ikke ofte, men noen ganger kan det være veldig nødvendig. Et TreeSet er en samling som lagrer elementer som et verdiordnet tre. Inne i TreeSet<E> er et TreeMap<E, Object> som lagrer alle disse verdiene. Og dette TreeMapbruker et rød-svart balansert binært tre for å lagre elementer. Derfor har den veldig raske add() , remove() , contains() operasjoner.

Lag et sett objekt

For å lage et settobjekt kan du bruke ett av følgende skjemaer:

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

Her er et enkelt eksempel, hvor vi lager 2 sett- er, HashSet og LinkedHashSet , og legger til i hver for 5 elementer. Vi kan bruke add() -metoden for dette.

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);
    }
}

Her er resultatet av programmet: Som vi nevnte ovenfor, opprettholder ikke HashSet rekkefølgen på elementene, men LinkedHashSet gjør det. Det var LinkedHashSet som ga oss elementene i den rekkefølgen vi skrev dem til settet.

Java-settmetoder

Her er noen av Java Set viktige metoder:

• boolsk add(E e) . Legger til det spesifiserte elementet til settet hvis det ikke allerede er til stede (valgfri operasjon).

• boolsk fjern(Objekt o) . Fjerner det spesifiserte elementet fra dette settet hvis det er tilstede (valgfri operasjon).

• boolesk removeAll(Samling c) . Fjerner fra dette settet alle dets elementer som finnes i den angitte samlingen (valgfri operasjon).

• boolean retainAll(Samling c) . Beholder bare elementene i dette settet som finnes i den angitte samlingen (valgfri operasjon).

• void clear() . Fjerner alle elementene fra settet.

• Iterator iterator() . Returnerer en iterator over elementene i dette settet.

• int størrelse() . den brukes til å få antall elementer i settet.

• boolsk er Empty() . for å sjekke om Set er tomt eller ikke.

• boolsk inneholder(Objekt o) . Returnerer sant hvis dette settet inneholder det angitte elementet.

• Iterator iterator() . Returnerer en iterator over elementene i dette settet. Elementene returneres i ingen spesiell rekkefølge.

• Objekt[] tilArray() . Returnerer en matrise som inneholder alle elementene i dette settet. Hvis dette settet gir noen garantier for hvilken rekkefølge elementene returneres av iteratoren, må denne metoden returnere elementene i samme rekkefølge.

Metodene ligner på ArrayList , bortsett fra at add(Object o) -metoden bare legger til et objekt til settet hvis det ikke allerede er der. Returverdien til metoden er sann hvis objektet er lagt til, og usann ellers. Det er også noen metoder som er arvet fra Collection<> Interface: parallelStream() , removeIf() , stream() og forEach() -metoden arvet fra java.lang.Iterable Interface.

Java Set hovedoperasjoner eksempel

I dette eksemplet lager vi en rekke strenger og sender den til mySet ved å bruke Arrays.asList- operasjonen. Så fjerner vi et par elementer til, og legger til et par til. I dette tilfellet eksisterer et av elementene i settet allerede: det vil ikke bli lagt til. Vi vil også prøve operasjonene med å sjekke for tomhet isEmpty() , bestemme størrelsen på set size() og tømme settet for alle elementer 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());

   }
}

Resultatet av programmet er her:

Eksempel med LinkedHashSet og satt til Array

La oss skrive et annet program. I den vil vi lage et sett basert på LinkedHashSet , legge til elementer til det, og deretter konvertere settet til en matrise.

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]);

       }
   }

Her er resultatet av programmet:

Sett eksempel med iterator

La oss lage et sett, så skrive det ut ved hjelp av en iterator, og deretter fjerne alle partall fra det, også ved å bruke en iterator.

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);

       }
}

Resultatet av programmet er her:

Eksempel med TreeSet

Hvis sortering er viktig for deg, bruk TreeSet- implementering. I dette korte eksemplet vil vi fylle ut settet med navn på venner, som i de forrige eksemplene. Men i et sortert TreeSet vil elementene umiddelbart bli skrevet i sortert rekkefølge. I dette tilfellet vil navnene vises alfabetisk.

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);

   }

Utgangen er:

Korte konklusjoner

• Java Set- grensesnittet er en del av Java Collections Framework.

• Implementerte klasser: AbstractSet , ConcurrentHashMap.KeySetView , ConcurrentSkipListSet , CopyOnWriteArraySet , EnumSet , HashSet , JobStateReasons , LinkedHashSet , TreeSet .

• De mest populære Set- implementeringene er HashSet , LinkedHashSet og TreeSet .

• HashSet- elementrekkefølgen bestemmes av en kompleks algoritme. Hvis lagringsrekkefølge er viktig for deg, bruk en TreeSet- beholder, som lagrer objekter sortert i stigende rekkefølge i sammenligningsrekkefølge, eller et LinkedHashSet , som lagrer elementer i tilleggsrekkefølge.

• Oftest brukes sett for å teste medlemskap. Det vil si å sjekke om et objekt tilhører et gitt sett i matematisk forstand. Så oftest av alle Set- implementeringer i praksis, er HashSet vanligvis valgt. Denne implementeringen er optimalisert for raskt søk.

• Du kan ikke legge til dupliserte elementer i et sett, så du kan bruke implementeringer av Set- grensesnittet til å lagre unike elementer.

• Sett lar deg legge til bare ett null-element.

• Settet er ikke en liste og støtter ikke indekser eller posisjoner til elementene.