java collections framework tutorial
Denna handledning förklarar Java Collections Framework (JCF) i detaljer tillsammans med samlingshierarki, olika gränssnitt och fördelarna med JCF:
Hoppas dessa vältaliga handledning om detta Java-serien för nybörjare är verkligen hjälpsamma för att berika din kunskap om Java.
Vår tidigare handledning informerade mer om grundläggande I / O-operationer i Java . I denna handledning lär vi oss mer om Java Collections Framework (JCF).
Java Collections Framework (JCF) innehåller gränssnitt, abstrakta klasser och klasser som kan ge arkitekturen att lagra och manipulera en grupp objekt.
Vad du kommer att lära dig:
- Videohandledning om Java-samlingsramen
- Slutsats
Videohandledning om Java-samlingsramen
Kunskap om Arraylist i Java:
Ställ in gränssnitt och kögränssnitt i Java med exempel i realtid:
HashMap, TreeMap och HashTable i Java:
Hittills har vi sett variabler som lagrar olika typer av data. Dessa är enstaka enheter och är inte särskilt användbara när du har stora mängder data att lagra och hantera. Som vi vet är data den viktigaste beståndsdelen för databehandling.
Din applikation måste kunna extrahera och samla in data, bearbeta den för att ta reda på användbar information och även skicka den fram och tillbaka så att den används effektivt för att nå lösningarna.
I den här programvaruvärlden lagrar vi de data som behöver struktureras på ett visst sätt så att programvaran kan lagra, läsa, bearbeta och slutligen mata ut resultaten. Detta görs med hjälp av datastrukturer.
Nästan alla programmeringsspråk stöder datastrukturer. Datastrukturen kan definieras som en strukturerad representation av data. Programmeringsspråk tillhandahåller API-funktioner (Application Programming Interface) för att manipulera datastrukturerna.
Behov av insamlingsram
Före Java 1.2 stödde Java-programmeringsspråk datastrukturer som matriser, vektorer eller hashtabeller. Att utföra operationer på dessa datastrukturer var inte lätt eftersom det inte fanns något gemensamt gränssnitt som fungerade på dessa datastrukturer.
Programmerare brukade ha svårt att skriva algoritmer som skulle fungera för alla datastrukturer och var ett stort krångel. Det fanns ett behov av ett gemensamt gränssnitt som skulle fungera konsekvent på alla datastrukturer och även utföra operationer effektivt.
Senare kom Java med ett samlingsramverk som är en grupp av klasser och gränssnitt bestående av olika operationer som kan utföras på datastrukturer.
I den här Java-samlingshandledningen kommer vi att diskutera Java Collections Framework i allmänhet. Vi kommer att utforska var och en av samlingskomponenterna i våra kommande handledning.
Java Collections Framework
Innan vi definierar ett Java Collections Framework, ska vi lära känna innebörden av samling och ett ramverk.
En samling kan definieras som en grupp objekt. En samling är vanligtvis en enda enhet som består av mer än ett objekt. Ett ramverk är en programvara som har ett färdigt funktionellt gränssnitt eller arkitektur och som också innehåller en uppsättning klasser och gränssnitt som ska användas med det medföljande gränssnittet.
Ett samlingsram definieras som en enhetlig, färdigbyggd arkitektur som består av nedanstående.
# 1) Algoritmer
Dessa är metoder eller uppsättningar av uttalanden som kan hjälpa programmerare att söka, sortera och bearbeta insamlad data. Samlingen levereras med gränssnitt, klasser och algoritmer.
De applikationer som utvecklas genom att ärva samlingsramen har tillgång till dessa algoritmer och använder redan definierade metoder och procedurer.
# 2) Gränssnitt
Gränssnitt i Java tillhandahåller abstraktion av implementeringen, dvs. använder gränssnitt, användaren är inte medveten om detaljerna i implementeringen, men kan bara se de metoder och data som krävs för att skriva en applikation. Samlingsgränssnittet har många gränssnitt som kan implementeras av programmeraren för att skriva sina egna klasser.
# 3) Klasser
Klasserna i Collection Framework är datastrukturer som kan implementeras i ett program. Dessa klasser implementerar 'Collection' -gränssnittet och ärver därmed alla metoder och definitioner för samlingsgränssnittet.
En samlingsram används för att lagra och manipulera samlingen som är gruppen objekt.
Java-samlingsramen består av högpresterande algoritmer som utför standardoperationer som sökning, sortering och bearbetning. Det tillhandahåller olika standardimplementeringar inklusive LinkedList, TreeSet och HashSet för vilka gränssnitt finns.
Låt oss sedan förstå Java-samlingshierarkin.
Java-samlingshierarki
Alla klasser och gränssnitt som visas i nedanstående Java Collection-hierarki tillhör paketet 'java.util. *'.
Som visas i ovanstående diagram består Java Collection Hierarchy av olika klasser och gränssnitt. Som du kan se ärver varje klass från ett gränssnitt och alla klasser och gränssnitt ärver i sin tur från ett enda 'samlingsgränssnitt'.
Låt oss diskutera några vanliga metoder i samlingsgränssnittet tillsammans med en kort introduktion om var och en av klasserna och gränssnitten som visas i ovanstående hierarki.
Samlingsgränssnitt
Samlingsgränssnittet är rotgränssnittet. Alla klasser i samlingsramen implementerar samlingsgränssnittet. Detta innebär att varje samling kommer att ha de metoder som deklareras i samlingsgränssnittet.
Några av metoderna för samlingsgränssnittet ges nedan.
| Låt bli | Metodprototyp | Beskrivning |
|---|---|---|
| 7 | standard boolean removeIf (Predikera filter) | Ta bort alla element som uppfyller det givna predikatfiltret från samlingen. |
| 1 | offentlig int storlek () | Returnerar antalet element i en viss samling. |
| två | offentligt tomrum rensat () | Rensar samlingen genom att ta bort alla element från samlingen. |
| 3 | public boolean add (E e) | Infogar ett element e i samlingen. |
| 4 | public booleanaddAll (Collection c) | Infoga alla element i samlingen som ges av c i samlingen. |
| 5 | public boolean remove (Objektelement) | Ta bort element som ges av 'element' från samlingen. |
| 6 | public boolean removeAll (Collectionc) | Ta bort samlingen c från samlingen. |
| 8 | public booleanretainAll (Collection c) | Ta bort alla element från samlingen utom de i den angivna samlingen c. |
| 9 | offentlig iterator iterator () | Returnera iterator för samlingen. |
| 10 | offentligt objekt () toArray () | Konvertera samlingen till en matris. |
| elva | allmän T () till Array (T () a) | Konvertera samlingen till en matris med en angiven returtyp. |
| 12 | public boolean isEmpty () | Returnera om samlingen är tom eller inte. |
| 13 | public boolean contains (Object element) | Kontrollera om en samling innehåller det angivna elementet (sökoperation). |
| 14 | public booleancontainsAll (Collectionc) | Kontrollera om samlingen innehåller specificerad samling c inuti den. |
| femton | standard Spliterator spliterator () | Returnerar spliterator över en viss samling. |
| 16 | public booleanequals (Object element) | Används för att matcha två samlingar. |
| 17 | standard Stream parallelStream () | Returnerar parallell ström med samlingen som källa. |
| 18 | standard Streamstream () | Returnerar sekventiell ström med samlingen som källa. |
| 19 | public int hashCode () | Returnerar den numeriska hashkoden för samlingen. |
Iterabelt gränssnitt
Iterabelt gränssnitt är också basgränssnittet för samlingsramen. Samlingsgränssnittet som är modergränssnittet för alla andra klasser utökar det Iterabla gränssnittet. Därför implementerar alla klasser ett samlingsgränssnitt såväl som ett Iterabelt gränssnitt.
Iterabelt gränssnitt har bara en metod iterator () som returnerar iteratorn () som du kan använda för att iterera över elementen av typ T.
Iterator iterator ()Iteratorgränssnitt
Iteratorgränssnittet ger möjlighet att iterera över elementen i en framåtriktning.
Följande är de metoder som stöds av detta gränssnitt.
| Låt bli | Metodprototyp | Beskrivning |
|---|---|---|
| 1 | offentligt objekt nästa () | Först returnerar elementet och flyttar sedan markören för att peka på nästa element. |
| två | public boolean hasNext () | Kontrollerar om iteratorn har fler element. |
| 3 | offentligt tomrum ta bort () | Tar bort elementet som returneras av iteratorn till slut. |
Listgränssnitt
Listgränssnittet ärver samlingsgränssnittet. Listgränssnittet innehåller datastrukturerna som används för att lagra beställd data eller insamling av objekt. Dessa datastrukturer är av listtyp. Dessa datastrukturer som implementerar listgränssnittet kan ha dubbla värden eller inte.
Listgränssnittet innehåller de metoder som används för att komma åt, infoga eller ta bort element från listobjekten.
Olika klasser som implementerar listgränssnittet är som följer:
vad man ska öppna xml-filer med
- ArrayList
- Länkad lista
- Vektor
- Stack
Vi kommer att diskutera var och en av dessa klasser kort. Våra efterföljande ämnen kommer att ha en detaljerad diskussion om var och en av samlingsramklasserna.
# 1) ArrayList
ArrayList är det enklaste implementeringen av List-gränssnittet. ArrayList bevarar infogningsordningen och den synkroniseras inte.
Den allmänna definitionen av ArrayList datastruktur (Collection) är som följer:
List list1= new ArrayList ();När listan har definierats kan du använda metoden 'lägg till' för att lägga till element. Observera att internt använde ArrayList dynamisk matrismekanism.
Se följande exempel som skapar en ArrayList-samling av färger.
import java.util.*; class Main { public static void main(String args()) { //Creating arraylist of String objects ArrayList color_list=new ArrayList(); //populate the arraylist with add method color_list.add('Red'); color_list.add('Green'); color_list.add('Blue'); color_list.add('Cyan'); color_list.add('Magenta'); color_list.add('Yellow'); //Traverse the list through Iterator Iterator itr=color_list.iterator(); System.out.println('The contents of the arraylist are:'); while(itr.hasNext()){ System.out.println(itr.next()); } } } Produktion:
Ovanstående program visar demonstrationen av ArrayList-samlingen. Vi lägger till färgvärden i samlingen och korsar sedan samlingen för att visa enskilda värden i samlingen med hjälp av en iterator.
# 2) LinkedList
LinkedList-samlingen använder internt en dubbelt länkad mekanism för att lagra element. Den kan innehålla dubbletter. Insamlingsåtgärderna för LinkedList går snabbare eftersom det inte krävs att skifta element.
Den allmänna definitionen av att skapa en länkad lista är som följer:
List list2 = new LinkedList ();Följande program demonstrerar den länkade listans samling av nummernamn .
import java.util.*; class Main { public static void main(String args()) { //linked list of String objects LinkedList linkedlist_num=new LinkedList(); linkedlist_num.add('one'); linkedlist_num.add('two'); linkedlist_num.add('three'); linkedlist_num.add('four'); linkedlist_num.add('five'); //iterate over the linked list to display contents Iterator itr=linkedlist_num.iterator(); System.out.println('The contents of the linked list are:'); while(itr.hasNext()) { System.out.println(itr.next()); } } } Produktion:
Således skapar vi en länkad lista och lägger sedan till element i den med 'lägg till' -metoden. Sedan använder vi en iterator, vi korsar den länkade listan och visar varje element.
# 3) Vektor
Vector liknar ArrayList och använder en dynamisk array för att lagra element som ArrayList. Men vektor stöder många oberoende metoder bortsett från samlingen som gör det till ett bättre val att vara en föredragen samling.
Den allmänna definitionen för vektorsamling är:
List list3 = new Vector();Observera att även om vektor och ArrayList använder samma mekanism för dynamiska matriser, är vektorelementen synkroniserade.
Java-programmet som ges nedan visar användningen av vektorer i samlingsramen .
import java.util.*; public class Main { public static void main(String args()) { Vector subject_vector=new Vector(); subject_vector.add('English'); subject_vector.add('Hindi'); subject_vector.add('Maths'); subject_vector.add('Science'); Iterator itr=subject_vector.iterator(); System.out.println('Vector contents:'); while(itr.hasNext()) { System.out.println(itr.next()); } } } Produktion:
I detta program har vi definierat en vektorsamling bestående av ämnen. Vi lägger till olika ämnen och använder sedan en iterator för att mata ut elementen.
# 4) Stack
Stapeldatastrukturen implementerar LIFO-sättet för att infoga element. Stapeln är en underklass av klassvektorn (se samlingshierarkidiagrammet ovan). Förutom sina egna metoder stöder stapelsamlingen också metoderna för vektorsamling.
Den allmänna definitionen av Stack-samlingen är:
List list4 = new Stack();Följande program implementerar Stack-samlingen .
import java.util.*; public class Main { public static void main(String args()) { Stack even_stack = new Stack (); even_stack.push(2); even_stack.push(4); even_stack.push(6); even_stack.push(8); even_stack.push(10); System.out.println('The element removed from stack: ' + even_stack.pop()); Iterator itr=even_stack.iterator(); System.out.println('The contents of the stack are:'); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } } } Produktion:
Som du kan se i implementeringen ovan läggs de nya elementen till i stacken med hjälp av 'skjuta på' drift. Stapeln har en enda ingångspunkt som heter 'Top of the stack' och elementen trycks på stacken högst upp. Således är det sista elementet som läggs till högst upp på stacken.
Som att lägga till tas element också bort från ena änden, dvs. toppen av stacken. För att ta bort element används en ”pop” -operation. Således om du ringer pop () kommer elementet högst upp i stacken att tas bort.
I utgången ovan sätter vi in elementet 2, 4, 6,8,10 och ringer sedan pop () så att 10 tas bort.
Kögränssnitt
Samlingarna som härrör från kögränssnittet följer FIFO-ordern (först-in-först-ut). Elementen sätts in i ena änden och tas bort från den andra änden. Därför råkar det inmatade elementet vara det element som tas bort först.
Nedan följer de samlingar som stöder sökgränssnittet.
- PriorityQueue
- och gränssnitt
- ArrayDeque
Låt oss diskutera vart och ett av dessa kort.
# 1) PriorityQueue
I PriorityQueue-samlingen bearbetas de lagrade elementen baserat på deras prioriteringar. Du kan inte lagra nollvärden i prioritetskön.
Den allmänna definitionen av prioritetskön är som följer:
Queue q1 = new PriorityQueue();Programmet nedan implementerar prioritetskön.
import java.util.*; public class Main { public static void main(String args()) { PriorityQueue color_queue=new PriorityQueue(); color_queue.add('red'); color_queue.add('green'); color_queue.add('blue'); color_queue.add('cyan'); color_queue.add('magenta'); color_queue.add('yellow'); System.out.println('Priority Queue elements:'); System.out.println('head:'+color_queue.peek()); System.out.println('Other elements in Priority Queue:'); Iterator itr=color_queue.iterator(); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } System.out.println('
'); color_queue.remove(); System.out.println('After removing element, new head:'+color_queue.element()); System.out.println('
'); color_queue.poll(); System.out.println('After removing another element, Priority Queue :'); Iterator itr2=color_queue.iterator(); while(itr2.hasNext()) { System.out.print(itr2.next() + ' '); } } } Produktion:
Återigen använder vi färger som element i prioritetskön. I ovanstående program har vi använt metoderna lägga till och ta bort för att lägga till element i kön respektive ta bort ett element. Vi använder metoden peek () som returnerar ett element som det pekar på i prioritetskön.
Slutligen med en iterator visas elementen i prioritetskön.
# 2) Touch-gränssnitt
Deque eller en 'dubbelkö' är en datastruktur som låter dig lägga till och ta bort elementen från båda ändarna. Deque-gränssnittet i Java-samlingsramen som utökar kögränssnittet.
Den tillhandahåller funktionaliteten hos deque och har en klass som en 'ArrayDeque' ärver från den.
# 3) ArrayDeque
ArrayDeque implementerar deque-gränssnittet.
Den allmänna definitionen av ArrayDeque är som följer:
Deque d = new ArrayDeque();Med ArrayDeque kan du använda funktionerna i Deque. Till skillnad från andra samlingar som ArrayList eller stack har ArrayDeque inga begränsningar för dess kapacitet.
Följande exempel visar implementeringen av ArrayDeque.
import java.util.*; public class Main { public static void main(String() args) { //Creating Deque and adding elements Deque deque = new ArrayDeque (); deque.add(10); deque.add(20); deque.add(30); System.out.println('Deque Elements:'); //Traversing elements for (Integer num : deque) { System.out.println(num); } } } Produktion:
I ovanstående program definierar vi en ArrayDeque-samling av typen heltal och lägger till helelement till den med hjälp av add-metoden. Samlingen passeras sedan med hjälp av for construct.
Ställ in gränssnitt
Det inställda gränssnittet är en del av paketet java.util och sträcker sig från samlingsgränssnittet. Set är en struktur som inte tillåter att samlingen har dubbla värden och också mer än ett nullvärde.
Följande klasser implementerar det inställda gränssnittet.
- HashSet
- LinkedHashSet
- TreeSet
# 1) HashSet
HashSet-samlingen som implementerar Set-gränssnittet har distinkta värden lagrade i den. Denna samling använder hashingtekniken för att lagra artiklarna och använder hashtabellen för att lagra element.
T den allmänna definitionen av HashSet-samlingen visas nedan.
Set s1 = new HashSet();Vi har gett HashSet-implementeringen i följande program.
import java.util.*; public class Main { public static void main(String args()) { //Create HashSet set_subjects HashSet set_subjects=new HashSet(); System.out.println('Elements in the given hashsetset_subjects are:'); set_subjects.add('Maths'); set_subjects.add('Computers'); set_subjects.add('English'); set_subjects.add('French'); //Traverse the hashset Iterator itr=set_subjects.iterator(); while(itr.hasNext()) { System.out.println(itr.next()); } } } Produktion:
I ovanstående program skapar vi en HashSet-samling av ämnen och korsar den sedan med hjälp av en iterator för att visa elementen i samlingen.
# 2) LinkedHashSet
LinkedHashSet implementerar ett gränssnitt och utvidgar HashSet (referenshierarki). LinkedHashSet är den länkade representationen av gränssnittet Set. LinkedHashSet innehåller unika element men tillåter nullvärden.
Den allmänna definitionen av LinkedHashSet ges nedan.
Set s2 = new LinkedHashSet();Implementeringen för LinkedHashSet ges nedan.
import java.util.*; public class Main { public static void main(String args()) { LinkedHashSet set_subjects=new LinkedHashSet(); System.out.println('Elements in the LinkedHashSet set_subjects:'); set_subjects.add('Maths'); set_subjects.add('Computers'); set_subjects.add('English'); set_subjects.add('Sanskrit'); Iterator itr=set_subjects.iterator(); while(itr.hasNext()) { System.out.println(itr.next()); } } } Produktion:
Återigen använder vi oss av boktitlar för att skapa Linkedhashset. Som du kan se från utgången bibehålls ordningen för tillägg av linkedHashSet.
SortedSet-gränssnitt
SortedSet-gränssnittet möjliggör fullständig beställning av element. Den innehåller metoder som ger en naturlig ordning av element. Element i samlingen som implementerar SortedSet-gränssnittet ordnas i ökande ordning.
TreeSet-klassen är ett av exemplen som implementerar SortedSet-gränssnittet.
Trädgrupp
Den allmänna definitionen av Treeset är som följer:
Set s3 = new TreeSet();TreeSet implementerar SortedSet-gränssnittet och innehåller unika element. Lagring och hämtning är ganska snabbt och sedan ordnas elementen i stigande ordning.
import java.util.*; public class Main{ public static void main(String args()) { //create a treeset of integers TreeSet set_oddnums=new TreeSet (); set_oddnums.add(1); set_oddnums.add(3); set_oddnums.add(5); set_oddnums.add(7); set_oddnums.add(9); System.out.println('Elements in TreeSet are:'); //traverse the treeset using iterator Iterator itr=set_oddnums.iterator(); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } } } Produktion:
I ovanstående program skapade vi och lade till udda nummer i samlingen med hjälp av läggningsmetoder. Sedan använder vi en iterator och skickar ut elementen i samlingen.
Fördelar med Java Collections Framework
- Minskad programmering: Samlingsramen kommer med alla gränssnitt och klasser som innehåller metoderna som gör det möjligt för programmerare att skriva ett effektivt program. På så sätt behöver programmeraren inte fokusera på för mycket programmering.
- Konsekventa metoder och API: Alla klasser har vanliga metoder som agerar på data. Dessa API: er är konsekventa i klasserna och programmeraren behöver inte oroa sig för att ha för många olika metoder för varje klass.
- Öka hastighet och noggrannhet: Du kan skriva mycket effektiva program med hjälp av en samlingsram och även snabbare och noggrannare program eftersom samlingsramen ger full funktionalitet för att implementera datastrukturer och samlingar.
- Underlättar återanvändning av programvara: Datastrukturer och algoritmer i Java-samlingsramen kan återanvändas.
- Interoperabilitet bland orelaterade API: er: Samlings-API: er möjliggör interoperabilitet även bland icke-relaterade API: er.
- Färre ansträngningar för att utforma nya API: er: Programmerare kan använda standard-samlings-API: erna och utforma nya API: er baserat på det. De behöver inte kämpa för att skriva helt nya API: er.
Vanliga frågor
# 1) Vad är användningen av ett samlingsramverk i Java?
bästa dataräddningsprogrammet för Windows
Svar: Samlingsramen erbjuder förpackade algoritmer, gränssnitt och klasser som gör det möjligt för programmerare att skriva mycket effektiva program som kan lagra och bearbeta data.
# 2) Varför är insamling ett ramverk?
Svar: Ett ramverk är en återanvändbar samling av klasser, gränssnitt och algoritmer. Samlingsramen är också en återanvändbar samling av datastrukturklasser och algoritmer som fungerar på dessa klasser.
# 3) Vad är Java Collections API i Java?
Svar: API: et för Java-samlingar tillhandahåller gränssnitt och klasser som kan utökas och implementeras för att använda datastrukturer som bara är samlingar.
# 4) Vad är skillnaden mellan samling och samlingar i Java?
Svar: Samlingen är ett basgränssnitt i samlingsramen medan 'samlingar' är en klass. Båda är en del av java.util-paketet.
**** Mer information och exempel på Java Collections Framework: ****
Jämförelse mellan lista, uppsättning och kö:
| Lista | Uppsättning | Kö |
|---|---|---|
| Införingsordningen bibehålls | Införingsordningen bibehålls inte i Hash-uppsättningen | Införingsordningen bibehålls. |
| Kan innehålla dubbletter | Kan inte innehålla dubbletter | Kan innehålla dubbletter. |
| Insättning och borttagning av array kan göras för vilket index som helst. | Ta bort det angivna elementet. | Endast det senast införda elementet kan poppas ut. Insättning av element sker också i slutet. |
Array List Class
I Array är minnestilldelningen fixad. Men i ArrayList kan minnet allokeras dynamiskt. Denna ArrayList-klass behåller infogningsordningen och du kan infoga dubbletter.
Demoprogram för Array List:
public class ArrayListDemo { public static void main(String() args) { ArrayList li = new ArrayList (); li.add(1); li.add(2); li.add(3); li.remove(0); for (Integer temp : li) { System.out.println(temp); } System.out.println('=========='); ArrayList l = new ArrayList(); l.add('text1'); l.add('text2'); l.add('text3'); for (String temp : l) { System.out.println(temp); } System.out.println('=========='); ArrayList al=new ArrayList(); al.add(1); al.add(2); al.forEach((a)->;System.out.println(a)); } } 
LinkedList-klass
Länkad datastruktur innehåller noder och denna nod kommer att innehålla två delar:
- Data
- Hänvisning till nästa element
Den första noden är inte en separat nod. Den innehåller endast referensen och kallas ett huvud. Den sista noden är noll.
Demoprogram:
public class LinkedListDemo { public static void main(String() args) { LinkedList list =new LinkedList(); list.add(22); list.add(44); list.add(46); list.add(46); list.add(46); for(Integer temp:list) { System.out.println(temp); } Iterator it =list.iterator(); while(it.hasNext()) { System.out.println(it.next()); } System.out.println('=========='); for (int i=0;i 
Kö
En kö är först in först ut (FIFO) datastruktur. Om du anropar borttagningsmetoden tas alltid det första infogade elementet bort från kön. Så kö används i realtidsprogram där data måste hämtas i den infogade ordningen.
Exempel på program:
public class QueueDemo { public static void main(String() args) { PriorityQueue pq=new PriorityQueue(); pq.add(1); pq.add(2); pq.add(3); pq.add(4); pq.add(5); pq.add(6); pq.add(7); for(int temp : pq) { System.out.println(temp); } pq.remove(); System.out.println('queue after removing a element'); System.out.println(pq); } } 
Uppsättning
En uppsättning samling tillåter inte dubbla element. Du kan använda en uppsatt datastruktur när du vill bearbeta insamlingen av data utan duplicering och när det inte finns något behov av att behålla insättningsordningen.
Demoprogram:
public class demohashset { public static void main (String() args){ HashSet hs=new HashSet(); hs.add(23); hs.add(24); hs.add(25); hs.add(26); hs.add(27); hs.add(28); hs.add(293); hs.add(203); hs.add(263); hs.add(243); hs.add(243); (int temp:hs) { System.out.println(temp); } hs.remove(24); hs.remove(23); System.out.println('==============='); System.out.println('after removing a element ::::'); System.out.println('==============='); hs.forEach((temp)->System.out.println(temp)); ; } } 
MAP-gränssnitt
- När du vill ha processamling av element med nyckel- och värdeparet kan du använda kartdatastrukturen eftersom kartan är ett objekt som kan mappa nycklar till värden.
- En karta kan inte innehålla dubbla nycklar.
- De viktiga implementeringarna av kartan är HashMap, Treemap, LinkedHashMap, HashTable.
Skillnad mellan HashMap, Treemap, LinkedHashMap och HashTable:
HashMap TreeMap LinkedHashmap HashTable Nollknappar och värden är tillåtna Endast nollvärden tillåtna. Nollknappar och värden tillåtna. Det tillåter inte nollnycklar och värden. Ej synkroniserad Ej synkroniserad Ej synkroniserad synkroniserad Det finns ingen garanti för att upprätthålla ordningen i iterationen Sortering kommer att göras baserat på naturlig ordning. Införingsordningen kommer att bibehållas Införingsordern bibehålls inte.
Demoprogram:
public class HashMapDemo { public static void main(String() args) { HashMap m=new HashMap(); m.put(1, 'one'); m.put(2, 'two'); m.put(3, 'three'); m.put(4, 'four'); m.put(null, 'one'); m.put(null, null); System.out.println(m); TreeMap tm =new TreeMap(); tm.put('R', 'red'); tm.put('B', null); tm.put('G', 'green'); System.out.println(tm); Hashtable ht =new Hashtable(); ht.put(1, 'one'); ht.put(2, 'two'); ht.put(3, 'three'); ht.put(4, 'four'); System.out.println(ht); } } 
Viktiga punkter att notera:
- Lista, kö, sätt gränssnitt förlänga samlingsgränssnittet och detta samlingsgränssnitt har vanliga metoder som att lägga till, ta bort etc.
- Införingsordningen hålls i listan och en uppsättning kan inte innehålla dubbletter. Kön är först in i först ut datastruktur.
- Kartan innehåller nyckel- och värdepar. HashMap, Treemap, Hashtable, Linked HashMap är den viktiga implementeringen av kartgränssnittet.
Slutsats
Denna handledning gav oss en introduktion till Java Collections Framework. Vi berörde kort alla klasser och gränssnitt som ingår i Java-samlingsramen.
I våra efterföljande handledning i denna serie lär vi oss i detalj om var och en av dessa klasser och gränssnitt.
Du kan utforska mer om reflektioner i JAVA i vår kommande handledning !!!
PREV-handledning | NÄSTA självstudie
Rekommenderad läsning
- Java Reflection Tutorial med exempel
- Fördjupade förmörkningsövningar för nybörjare
- Java SWING-handledning: Container, komponenter och händelsehantering
- JAVA-handledning för nybörjare: 100+ praktiska Java-videohandledning
- Åtkomstmodifierare i Java - Handledning med exempel
- Java String med String Buffer och String Builder Tutorial
- Introduktion till Java-programmeringsspråk - Videohandledning
- Gurkselen-handledning: Gurka Java Selen WebDriver-integration
