set interface java
Denna Java Set-handledning förklarar allt om Set-gränssnittet i Java. Det täcker hur man kan växla igenom en uppsättning, ange metoder, implementering, ange till lista, etc.:
Set in Java är ett gränssnitt som ingår i Java Collection Framework och implementerar Collection-gränssnittet. En uppsättningssamling innehåller funktionerna i en matematisk uppsättning.
En uppsättning kan definieras som en samling oordnade objekt och den kan inte innehålla dubbla värden. Eftersom det inställda gränssnittet ärver samlingsgränssnittet implementerar det alla metoder för samlingsgränssnittet.
=> Kolla in den perfekta Java-träningsguiden här.
Vad du kommer att lära dig:
Java-uppsättning
Det inställda gränssnittet implementeras av klasser och gränssnitt som visas i nedanstående diagram.
Som visas i ovanstående diagram är Set-gränssnitt ärvt av klasser, HashSet, TreeSet, LinkedHashSet och EnumSet. Gränssnitten SortedSet och NavigableSet implementerar också Set-gränssnittet.
Några av de viktiga egenskaperna för Set-gränssnittet ges nedan:
- Det inställda gränssnittet är en del av Java Collections Framework.
- Det inställda gränssnittet möjliggör unika värden.
- Det kan ha högst ett nollvärde.
- Java 8 ger en standardmetod för det inställda gränssnittet - Spliterator.
- Det inställda gränssnittet stöder inte elementens index.
- Det inställda gränssnittet stöder generiska.
Hur man skapar en uppsättning?
Det inställda gränssnittet i Java är en del av paketet java.util. För att inkludera ett inställt gränssnitt i programmet måste vi använda något av följande importuttalanden.
import java.util.*; eller
import java.util.Set; När inställt gränssnittsfunktionalitet ingår i programmet kan vi skapa en uppsättning i Java med hjälp av någon av de inställda klasserna (klasser som implementerar setgränssnittet) som visas nedan.
Set colors_Set = new HashSet(); Vi kan sedan initiera detta uppsatta objekt genom att lägga till några element till det med hjälp av add-metoden.
colors_Set.add(“Red”); colors_Set.add(“Green”); colors_Set.add(“Blue”); Sätt exempel på Java
Låt oss implementera ett enkelt exempel i Java för att demonstrera Set-gränssnittet.
import java.util.*; public class Main { public static void main(String() args) { // Set demo with HashSet Set Colors_Set = new HashSet(); Colors_Set.add('Red'); Colors_Set.add('Green'); Colors_Set.add('Blue'); Colors_Set.add('Cyan'); Colors_Set.add('Magenta'); //print set contents System.out.print('Set contents:'); System.out.println(Colors_Set); // Set demo with TreeSet System.out.print('
Sorted Set after converting to TreeSet:'); Set tree_Set = new TreeSet(Colors_Set); System.out.println(tree_Set); } }Produktion:
Ange innehåll: (Röd, Cyan, Blå, Magenta, Grön)
Sorterad uppsättning efter konvertering till TreeSet: (Blå, Cyan, Grön, Magenta, Röd)
Iterera genom uppsättning i Java
Vi kan komma åt vart och ett av elementen i en uppsättning med olika metoder. Vi kommer att diskutera dessa tillvägagångssätt nedan.
Använda Iterator
Vi kan definiera en iterator som ska korsas genom ett uppsatt objekt. Med hjälp av denna iterator kan vi komma åt varje element i uppsättningen och bearbeta det.
Följande Java-program visar iterering genom uppsättningen och skriver ut uppsättningselementen.
import java.util.*; import java.util.HashSet; public class Main { public static void main(String args()) { // Create a HashSet object and initialize it Set cities_Set = new HashSet(); cities_Set.add('Bangaluru'); cities_Set.add('Pune'); cities_Set.add('Hyderabad'); cities_Set.add('Kolkata'); // Print the set contents System.out.println('HashSet: ' + cities_Set); // Create an iterator for the cities_Set Iterator iter = cities_Set.iterator(); // print the set contents using iterator System.out.println('Values using Iterator: '); while (iter.hasNext()) { System.out.print(iter.next()+ ' '); } } }Produktion:
HashSet: (Bangaluru, Pune, Kolkata, Hyderabad)
Värden som använder Iterator:
Bangalore Pune Kolkata Hyderabad
Använda för varje slinga
Vi kan också använda för varje slinga för att komma åt elementen i en uppsättning. Här itererar vi genom uppsättningen i en slinga.
Följande program visar detta.
import java.util.*; import java.util.HashSet; public class Main { public static void main(String args()) { // Create a HashSet object and initialize it Set cities_Set = new HashSet(); cities_Set.add('Bangaluru'); cities_Set.add('Pune'); cities_Set.add('Hyderabad'); cities_Set.add('Kolkata'); // Print the set contents System.out.println('HashSet: ' + cities_Set); System.out.println('
Set contents using forEach loop:'); // print the set contents using forEach loop for(String val : cities_Set) { System.out.print(val + ' '); } } } Produktion:
HashSet: (Bangaluru, Pune, Kolkata, Hyderabad)
Ställ in innehåll med forEach loop:
Bangalore Pune Kolkata Hyderabad
Använda Java 8 Stream API
Vi kan också iterera och komma åt uppsättningselement med Java 8 stream API. I detta genererar vi en ström från en uppsättning och itererar sedan igenom strömmen med hjälp av forEach-slingan.
Java-programmet nedan visar iteration av uppsättningen med Java 8 stream API.
import java.util.*; import java.util.HashSet; import java.util.stream.*; public class Main { public static void main(String args()) { // Create a HashSet object and initialize it Set cities_Set = new HashSet(); cities_Set.add('Bangaluru'); cities_Set.add('Pune'); cities_Set.add('Hyderabad'); cities_Set.add('Kolkata'); // Print the set contents System.out.println('HashSet: ' + cities_Set); System.out.println('
Set contents using Java 8 stream API:'); //generate a stream from set Stream stream = cities_Set.stream(); //iterate the stream using forEach loop to print the elements stream.forEach((element) -> { System.out.print(element + ' '); }); } }Produktion:
HashSet: (Bangaluru, Pune, Kolkata, Hyderabad)
Ställ in innehåll med Java 8 stream API:
Bangalore Pune Kolkata Hyderabad
Ställ in metod-API
Nedan visas metoderna som stöds av Set-gränssnittet. Dessa metoder utför grundläggande åtgärder som att lägga till, ta bort, innehåller etc. tillsammans med de andra åtgärderna.
program för att ladda ner videor från vilken webbplats som helst
| Metod | Metodprototyp | Beskrivning |
|---|---|---|
| är tom | boolean isEmpty () | Kontrollerar om uppsättningen är tom |
| Lägg till | boolesk tillsats (E e) | Lägger till elementet e till uppsättningen om det inte finns i uppsättningen |
| Lägg till alla | boolean addAll (Collection c) | Lägger till elementet i samlingen c till uppsättningen. |
| ta bort | boolean ta bort (Objekt o) | Raderar det givna elementet o från uppsättningen. |
| ta bort alla | boolean removeAll (samling c) | Tar bort elementen i den givna samlingen c från uppsättningen. |
| innehåller | boolean innehåller (Objekt o) | Kontrollerar om det givna elementet o finns i uppsättningen. Returnerar sant om ja. |
| innehållerAll | boolean containAll (Collection c) | Kontrollerar om uppsättningen innehåller alla element i den angivna samlingen. Returnerar sant om ja. |
| behållAllt | boolean retainAll (Collection c) | Set behåller alla element i den givna samlingen c |
| klar | ogiltig rensa () | Rensar uppsättningen genom att ta bort alla element från uppsättningen |
| iterator | Iterator iterator () | Används för att få iteratorn för uppsättningen |
| toArray | Objekt () toArray () | Konverterar uppsättningen till matrisrepresentation som innehåller alla element i uppsättningen. |
| storlek | int storlek () | Returnerar det totala antalet element eller storleken på uppsättningen. |
| hash-kod | hash-kod () | Returnerar hashCode för uppsättningen. |
Låt oss nu implementera några av metoderna som vi diskuterade ovan i ett Java-program. Vi kommer också att se följande specifika operationer som involverar två uppsättningar.
Ställ in implementering i Java
Genomskärning: Vi behåller gemensamma värden mellan de två uppsättningarna. Vi utför en korsning med hjälp av behållAllt metod.
Union: Här kombinerar vi de två uppsättningarna. Detta görs med Lägg till alla metod.
Skillnad: Denna åtgärd tar bort en uppsättning från den andra. Denna operation utförs med hjälp av ta bort alla metod.
import java.util.*; public class Main { public static void main(String args()) { //declare a set class (HashSet) Set numSet = new HashSet(); //add an element => add numSet.add(13); //add a list to the set using addAll method numSet.addAll(Arrays.asList(new Integer() {1,6,4,7,3,9,8,2,12,11,20})); //print the set System.out.println('Original Set (numSet):' + numSet); //size() System.out.println('
numSet Size:' + numSet.size()); //create a new set class and initialize it with list elements Set oddSet = new HashSet(); oddSet.addAll(Arrays.asList(new Integer() {1, 3, 7, 5, 9})); //print the set System.out.println('
OddSet contents:' + oddSet); //contains () System.out.println('
numSet contains element 2:' + numSet.contains(3)); //containsAll () System.out.println('
numSet contains collection oddset:' + numSet.containsAll(oddSet)); // retainAll () => intersection Set set_intersection = new HashSet(numSet); set_intersection.retainAll(oddSet); System.out.print('
Intersection of the numSet & oddSet:'); System.out.println(set_intersection); // removeAll () => difference Set set_difference = new HashSet(numSet); set_difference.removeAll(oddSet); System.out.print('Difference of the numSet & oddSet:'); System.out.println(set_difference); // addAll () => union Set set_union = new HashSet(numSet); set_union.addAll(oddSet); System.out.print('Union of the numSet & oddSet:'); System.out.println(set_union); } }Produktion:
Originaluppsättning (numSet): (1, 2, 3, 4, 20, 6, 7, 8, 9, 11, 12, 13)
numSet Storlek: 12
OddSet-innehåll: (1, 3, 5, 7, 9)
numSet innehåller element 2: true
numSet innehåller oddset för samling: falskt
Korsning av numSet & oddSet: (1, 3, 7, 9)
Skillnad mellan numSet och oddSet: (2, 4, 6, 8, 11, 12, 13, 20)
Union av numSet & oddSet: (1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 20)
Ställ in på matris
Vi har sett metoden 'toArray' i ovanstående avsnitt om metoder. Denna toArray-metod kan användas för att konvertera uppsättningen till en Array.
Java-programmet nedan omvandlar Set till en Array.
import java.util.*; public class Main { public static void main(String() args) { //declare a set class (HashSet) Set setOfColors= new HashSet(); // add data to HashSet setOfColors.add('Red'); setOfColors.add('Green'); setOfColors.add('Blue'); setOfColors.add('Cyan'); setOfColors.add('Magenta'); //print the set System.out.println('The set contents:' + setOfColors); //convert Set to Array using toArray () method String colors_Array() = setOfColors.toArray(new String(setOfColors.size())); //print the Array System.out.println('Set converted to Array:' + Arrays.toString(colors_Array)); } }Produktion:
Uppsättningens innehåll: (Röd, Cyan, Blå, Magenta, Grön)
Konvertera till Array: (Röd, Cyan, Blå, Magenta, Grön)
Array att ställa in
För att konvertera en matris till en uppsättning i Java kan vi följa två tillvägagångssätt som visas nedan.
# 1) Vi kan konvertera Array till en lista med asList-metoden och sedan skicka den här listan som ett argument till uppsättningskonstruktören. Detta resulterar i att det uppsatta objektet skapas med arrayelementen.
#två) Alternativt kan vi använda metoden Collections.addAll för att kopiera arrayelementen till det inställda objektet.
Java-programmet nedan implementerar båda dessa tillvägagångssätt för att konvertera en array till set.
import java.util.*; public class Main { public static void main(String() args) { //declare an array Integer() numArray = {10,50,40,20,60,30,80,70}; System.out.println('The input array:' + Arrays.toString(numArray)); //Approach 1: create a set class and provide array //converted to list as constructor arg Set numSet = new HashSet(Arrays.asList(numArray)); //print the set System.out.println('
Array converted to set through asList:' + numSet); //create another set Set intSet = new HashSet(); //Approach 2: use Collections.addAll method to copy array elements to the set Collections.addAll(intSet, numArray); //print the set System.out.println('
Array converted to set using Collections.addAll:' + intSet); } }Produktion:
Inmatningsmatrisen: (10, 50, 40, 20, 60, 30, 80, 70)
Array konverterad till set through asList: (80, 50, 20, 70, 40, 10, 60, 30)
Array konverterad till set med Collections.addAll: (80, 50, 20, 70, 40, 10, 60, 30)
Ange till lista
För att konvertera set till en lista i Java kan vi använda metoden 'addAll' i listklassen. Den här metoden kopierar innehållet i uppsättningen eller någon samling som tillhandahålls som ett argument till listan som åberopar metoden addAll.
Java-programmet nedan konverterar uppsättningen till en ArrayList.
import java.util.*; public class Main { public static void main(String() args) { //declare a set class and initialize it Set strSet= new HashSet(); strSet.add('one'); strSet.add('two'); strSet.add('three'); strSet.add('four'); strSet.add('five'); //print the set System.out.println('The set contents: ' + strSet); //declare an ArrayList List strList = new ArrayList(); //using addAll method,copy set elements to ArrayList strList.addAll(strSet); //print the ArrayList System.out.println('The ArrayList from set : ' + strList); } }Produktion:
Uppsättningens innehåll: (fyra, en, två, tre, fem)
ArrayList från set: (fyra, en, två, tre, fem)
Lista att ställa in
För att konvertera den angivna listan som ArrayList till en uppsättning i Java skickar vi listobjektet som ett argument till konstruktören för uppsättningen.
Följande Java-program genomför denna konvertering.
import java.util.*; public class Main { public static void main(String() args) { //declare an ArrayList and initialize it List strList = new ArrayList(); strList.add('one'); strList.add('two'); strList.add('three'); strList.add('four'); strList.add('five'); //print the ArrayList System.out.println('The ArrayList: ' + strList); //declare a set class with ArrayList as argument to the constructor Set strSet= new HashSet(strList); //print the set System.out.println('The Set obtained from ArrayList: ' + strSet); } }Produktion:
ArrayList: (en, två, tre, fyra, fem)
Uppsättningen erhållen från ArrayList: (fyra, en, två, tre, fem)
Sortera en uppsättning i Java
Set-samlingen i Java har ingen direkt sorteringsmetod. Så vi måste följa några indirekta metoder för att sortera eller ordna innehållet i det uppsatta objektet. Det finns dock ett undantag om det inställda objektet är en TreeSet.
TreeSet-objektet tillhandahåller som standard den beställda uppsättningen. Därför om vi är angelägna om den beställda uppsättningen element bör vi gå till TreeSet. För HashSet eller LinkedHashSet-objekt kan vi konvertera uppsättningen till List. Sortera listan med hjälp av Collections.sort () -metoden och konvertera sedan listan tillbaka till set.
Detta tillvägagångssätt visas i Java-programmet nedan.
import java.util.Arrays; import java.util.Collections; import java.util.*; public class Main{ public static void main(String() args) { //Declare a set and initialize it with unsorted list HashSet evenNumSet = new LinkedHashSet( Arrays.asList(4,8,6,2,12,10,62,40,36) ); //print the unsorted set System.out.println('Unsorted Set: ' + evenNumSet); //convert set to list List numList = new ArrayList(evenNumSet); //Sort the list using Collections.sort () method Collections.sort(numList); //convert set to list evenNumSet = new LinkedHashSet(numList); //convert list to set //Print the sorted set System.out.println('Sorted Set:' + evenNumSet); } }Produktion:
Osorterad uppsättning: (4, 8, 6, 2, 12, 10, 62, 40, 36)
Sorterad uppsättning: (2, 4, 6, 8, 10, 12, 36, 40, 62)
Lista mot inställda i Java
Låt oss diskutera några av skillnaderna mellan en lista och en uppsättning.
| Lista | Uppsättning |
|---|---|
| Nollvärden är tillåtna. | Endast ett nollvärde tillåtet. |
| Gränssnitt för implementeringslista. | Verktyg Ställ in gränssnitt. |
| Innehåller en Legacy-klass, Vector. | Inga äldre klasser. |
| ArrayList, LinkedList är implementeringar av listgränssnitt. | HashSet, TreeSet, LinkedHashSet är Set-implementeringar. |
| En ordnad sekvens av element. | En oordnad samling av distinkta element. |
| Tillåter dubbletter. | Inga dubbletter är tillåtna. |
| Kan komma åt element enligt elementets position. | Ingen positionell åtkomst. |
| Nya metoder definierade i ett listgränssnitt. | Inga nya metoder definierade i Set-gränssnittet. Samlingsgränssnittsmetoder ska användas med Set-underklasser. |
| Kan köras framåt och bakåt med ListIterator. | Det kan bara köras framåt med Iterator. |
Vanliga frågor
F # 1) Vad är en uppsättning i Java?
Svar: En uppsättning är en oordnad samling av unika element och modellerar vanligtvis begreppet Set i matematik.
Set är ett gränssnitt som utökar Collection-gränssnittet. Den innehåller de metoder som den ärver från samlingsgränssnittet. Det inställda gränssnittet lägger bara till en begränsning, dvs inga dubbletter ska tillåtas.
F # 2)Beställs uppsättningen i Java?
Svar: Nej. Java Set är inte beställt. Det ger inte positionell åtkomst också.
F # 3)Kan en uppsättning innehålla dubbletter?
Svar: En uppsättning är en samling unika element, den kan inte ha några dubbletter.
F # 4)Är Java Set iterabelt?
Svar: Ja. Set-gränssnittet implementerar ett Iterabelt gränssnitt och därmed kan set passeras eller iteras med en forEach-slinga.
F # 5)Är NULL tillåtet i uppsättningen?
Svar: En uppsättning tillåter nullvärde men högst ett nullvärde är tillåtet i setimplementeringar som HashSet och LinkedHashSet. I fallet med TreeSet kastar det körtidsundantag om null anges.
Slutsats
I denna handledning har vi diskuterat de allmänna begreppen och implementeringen relaterade till Set-gränssnittet i Java.
Det inställda gränssnittet har inga nya metoder definierade, men det använder metoderna i Collector-gränssnittet och lägger bara till implementering för att förbjuda dubbla värden. Uppsättningen tillåter högst ett nollvärde.
I våra efterföljande handledning kommer vi att diskutera specifika implementeringar av Set-gränssnittet som HashSet och TreeSet.
=> Besök här för att lära dig Java från Scratch.
vänta 1 sekund
Rekommenderad läsning
- Java Reflection Tutorial med exempel
- JAVA-handledning för nybörjare: 100+ praktiska Java-videohandledning
- Java String innehåller () Metodhandledning med exempel
- Jagged Array In Java - Handledning med exempel
- Java Scanner-klasshandledning med exempel
- Java Array Length Tutorial With Code Exempel
- Java String Tutorial | Java-strängmetoder med exempel
- Vad är Java Vector | Java Vector Class Tutorial med exempel