Java sæt

Set er en grænseflade i Java Collection Framework. Du kan bruge Java Set til at implementere uordnede samlinger med unikke elementer. I denne artikel skal vi se på denne grænseflade og dens implementeringer i Java-sproget, metoder til at arbejde med et sæt og også give nogle eksempler.

Hvad er Java Set

Set er en grænseflade fra Java Collection Framework, men Set er ikke en ordnet samling, i modsætning til List . Det betyder, at Java Set- elementer opbevares uden en bestemt rækkefølge. Så der er ingen kontrol over den position, hvor du kan indsætte et element. Du kan heller ikke få adgang til elementer efter deres indeks. Matematisk er et sæt en samling af unikke elementer. Faktisk er dette en uordnet samling (uordnet samling), hvor identiske elementer ikke kan gemmes. Hvis du med vilje tilføjer et dubletelement til et sæt , vil denne handling blive ignoreret, og sættet ændres ikke. Det er dog tilladt at gemme ét null-element i det.

Indstil implementeringer

Java Set er en grænseflade, så du skal bruge en af ​​dens implementeringer til at oprette objekter. Disse er HashSet , TreeSet og LinkedHashSet . I sæt s er hvert element kun gemt i én instans, og forskellige implementeringer af sæt bruger en anden rækkefølge til lagring af elementer. I et HashSet bestemmes rækkefølgen af ​​elementer af en kompleks algoritme. Hvis lagerrækkefølge er vigtig for dig, skal du bruge en TreeSet- beholder, som gemmer objekter sorteret i stigende rækkefølge i sammenligningsrækkefølge, eller et LinkedHashSet, som gemmer elementer i tillægsrækkefølge. Sæt bruges ofte til medlemstest, så man nemt kan tjekke om et objekt hører til et givent sæt, så i praksis vælges som regel en HashSet- implementering, der er optimeret til hurtigt opslag. HashSet er en samling, der bruger deres hash-værdier returneret af hashCode() -metoden til at gemme elementer internt. Det vil sige, at inde i HashSet<E> er HashMap <E, Object> objektet gemt, som gemmer værdierne af HashSet som nøgler. Ved at bruge hash-koder kan du hurtigt søge, tilføje og fjerne elementer fra et sæt . LinkedHashSet er et HashSetder også gemmer elementer i en sammenkædet liste. Et normalt HashSet opretholder ikke elementrækkefølge. For det første eksisterer den simpelthen ikke officielt, og for det andet kan selv den interne orden ændre sig dramatisk, når blot ét element tilføjes. Og du kan få en iterator fra LinkedHashSet og bruge den til at gennemgå alle elementerne i den nøjagtige rækkefølge, som de blev tilføjet til LinkedHashSet . Ikke ofte, men nogle gange kan det være meget nødvendigt. Et træsæt er en samling, der gemmer elementer som et værdiordnet træ. Inde i TreeSet<E> er et TreeMap<E, Object> , der gemmer alle disse værdier. Og dette TreeMapbruger et rød-sort balanceret binært træ til at gemme elementer. Derfor har den meget hurtige add() , remove() , contains() operationer.

Opret et sæt objekt

For at oprette et sætobjekt kan du bruge en af ​​følgende formularer:

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

Her er et simpelt eksempel, hvor vi opretter 2 sæt s, HashSet og LinkedHashSet , og tilføjer til hver for 5 elementer. Vi kan bruge add() metoden til 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 output fra programmet: Som vi nævnte ovenfor, opretholder HashSet ikke rækkefølgen af ​​elementer, men det gør LinkedHashSet . Det var LinkedHashSet , der gav os elementerne i den rækkefølge, vi skrev dem til sættet.

Java sæt metoder

Her er nogle af Java Set vigtige metoder:

• boolesk add(E e) . Tilføjer det angivne element til sættet, hvis det ikke allerede er til stede (valgfri betjening).

• boolesk fjern(Objekt o) . Fjerner det angivne element fra dette sæt, hvis det er til stede (valgfri betjening).

• boolean removeAll(Samling c) . Fjerner fra dette sæt alle dets elementer, der er indeholdt i den angivne samling (valgfri handling).

• boolean retainAll(Samling c) . Beholder kun de elementer i dette sæt, der er indeholdt i den angivne samling (valgfri drift).

• void clear() . Fjerner alle elementer fra sættet.

• Iterator iterator() . Returnerer en iterator over elementerne i dette sæt.

• int størrelse() . det bruges til at få antallet af elementer i sættet.

• boolean isEmpty() . for at kontrollere, om Set er tomt eller ej.

• boolesk indeholder(Objekt o) . Returnerer sand, hvis dette sæt indeholder det angivne element.

• Iterator iterator() . Returnerer en iterator over elementerne i dette sæt. Elementerne returneres i nogen bestemt rækkefølge.

• Objekt[] tilArray() . Returnerer en matrix, der indeholder alle elementerne i dette sæt. Hvis dette sæt giver nogen garantier for, hvilken rækkefølge dets elementer returneres af dets iterator, skal denne metode returnere elementerne i samme rækkefølge.

Metoderne ligner dem i ArrayList , bortset fra at add(Object o) -metoden kun tilføjer et objekt til sættet, hvis det ikke allerede er der. Metodens returværdi er sand, hvis objektet er tilføjet, og ellers falsk. Der er også nogle metoder, der er nedarvet fra Collection<> Interface: parallelStream() , removeIf() , stream() og forEach()- metoden arvet fra java.lang.Iterable Interface.

Java Set hovedoperationer eksempel

I dette eksempel opretter vi et array af strenge og sender det derefter til mySet ved hjælp af Arrays.asList - operationen. Så fjerner vi et par elementer mere og tilføjer et par mere. I dette tilfælde eksisterer et af elementerne i sættet allerede: det vil ikke blive tilføjet. Vi vil også prøve operationerne med at tjekke for tomhed isEmpty() , bestemme størrelsen af ​​set size() og rydde sættet af 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 af programmet er her:

Eksempel med LinkedHashSet og sat til Array

Lad os skrive et andet program. I den vil vi oprette et sæt baseret på LinkedHashSet , tilføje elementer til det og derefter konvertere sættet til et 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]);

       }
   }

Her er output fra programmet:

Sæt et eksempel med iterator

Lad os oprette et sæt, derefter udskrive det ved hjælp af en iterator, og derefter fjerne alle lige tal fra det, også ved hjælp af 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 af programmet er her:

Eksempel med TreeSet

Hvis sortering er vigtig for dig, så brug TreeSet implementering. I dette korte eksempel vil vi udfylde sættet med navne på venner, som i de foregående eksempler. Men i et sorteret TreeSet vil elementerne straks blive skrevet i sorteret rækkefølge. I dette tilfælde vil navnene blive vist 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);

   }

Udgangen er:

Korte konklusioner

• Java Set -grænsefladen er en del af Java Collections Framework.

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

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

• HashSet- elementrækkefølgen bestemmes af en kompleks algoritme. Hvis lagerrækkefølge er vigtig for dig, skal du bruge en TreeSet- container, som gemmer objekter sorteret i stigende rækkefølge i sammenligningsrækkefølge, eller et LinkedHashSet , som gemmer elementer i ekstra rækkefølge.

• Oftest bruges sæt til at teste medlemskab. Det vil sige at kontrollere, om et objekt tilhører en given mængde i matematisk forstand. Så oftest af alle Set- implementeringer i praksis, er HashSet normalt valgt. Denne implementering er optimeret til hurtig søgning.

• Du kan ikke tilføje duplikerede elementer til et sæt, så du kan bruge implementeringer af sæt- grænsefladen til at gemme unikke elementer.

• Set giver dig mulighed for kun at tilføje ét nul-element.

• Sæt er ikke en liste og understøtter ikke indekser eller positioner af dets elementer.