java collections framework tutorial
Denne vejledning forklarer Java Collections Framework (JCF) i detaljer sammen med Collection Hierarchy, Various Interfaces og Fordelene ved JCF:
Håber disse veltalende tutorials om dette Java-serien til begyndere er virkelig nyttige til at berige din viden om Java.
Vores tidligere vejledning orienterede mere om grundlæggende I / O-operationer i Java . I denne vejledning lærer vi detaljeret om Java Collections Framework (JCF).
Java Collections Framework (JCF) indeholder grænseflader, abstrakte klasser og klasser, som kan give arkitekturen til at gemme og manipulere en gruppe objekter.
Hvad du lærer:
- Video Tutorials On Java Collections Framework
- Konklusion
Video Tutorials On Java Collections Framework
Kendskab til Arraylist i Java:
Indstil grænseflade og køgrænseflade i Java med eksempler i realtid:
HashMap, TreeMap og HashTable i Java:
Indtil videre har vi set variabler, der gemmer forskellige typer data. Disse er entalsenheder og er ikke særlig nyttige, når du har store mængder data at gemme og håndtere. Som vi ved, er data den vigtigste bestanddel af computerbehandling.
Din applikation skal være i stand til at udtrække og indsamle data, behandle dem for at finde nyttige oplysninger og også videregive dem frem og tilbage, så de bruges effektivt til at nå løsningerne.
I denne softwareverden gemmer vi de data, der skal struktureres på en bestemt måde, så softwareprogrammerne er i stand til at gemme, læse, behandle og endelig output resultaterne. Dette gøres ved hjælp af datastrukturer.
Næsten alle programmeringssprog understøtter datastrukturer. Datastrukturen kan defineres som en struktureret repræsentation af data. Programmeringssprog giver API-funktioner (Application Programming Interface) for at manipulere datastrukturer.
Behov for indsamlingsrammer
Før Java 1.2 understøttede Java-programmeringssprog datastrukturer som arrays, vektorer eller hash-tabeller. At udføre operationer på disse datastrukturer var ikke let, da der ikke var nogen fælles grænseflade, der fungerede på disse datastrukturer.
Programmører plejede at finde det vanskeligt at skrive algoritmer, der ville fungere for alle datastrukturer og var et stort besvær. Der var behov for en fælles grænseflade, der ville arbejde konsekvent på alle datastrukturer og også udføre operationer effektivt.
Senere kom Java med en samling ramme, som er en gruppe af klasser og grænseflader, der består af forskellige operationer, der kan udføres på datastrukturer.
I denne Java Collections Tutorial vil vi generelt diskutere Java Collections Framework. Vi vil udforske hver af samlingskomponenterne i vores kommende tutorials.
Java Collections Framework
Før vi definerer en Java Collections Framework, lad os lære betydningen af samling og en ramme at kende.
En samling kan defineres som en gruppe objekter. En samling er normalt en enkelt enhed bestående af mere end et objekt. En ramme er en software, der har en færdiglavet funktionel grænseflade eller arkitektur og også indeholder et sæt klasser og grænseflader, der skal bruges med den medfølgende grænseflade.
En ramme for samlinger er defineret som en samlet, færdiglavet arkitektur bestående af nedenstående.
# 1) Algoritmer
Dette er metoder eller sæt udsagn, der kan hjælpe programmører med at søge, sortere og behandle indsamlede data. Samlingen leveres pakket med grænseflader, klasser og algoritmer.
De applikationer, der er udviklet ved at arve indsamlingsrammen, har adgang til disse algoritmer og bruger de allerede definerede metoder og procedurer.
# 2) Grænseflader
Grænseflader i Java giver abstraktion af implementeringen, dvs. bruger grænseflader, brugeren er ikke opmærksom på detaljerne i implementeringen, men kan kun se de metoder og data, der kræves for at skrive en applikation. Samlingsgrænsefladen har mange grænseflader, der kan implementeres af programmøren til at skrive deres egne klasser.
# 3) Klasser
Klasserne i Collection Framework er datastrukturer, der kan implementeres i et program. Disse klasser implementerer 'Collection' -grænsefladen og arver således alle metoderne og definitionerne i samlingsgrænsefladen.
En samlingsramme bruges til at gemme og manipulere den samling, der er gruppen af objekter.
Java collection framework består af højtydende algoritmer, der udfører standardoperationer som søgning, sortering og behandling. Det giver forskellige standardimplementeringer, herunder LinkedList, TreeSet og HashSet, for hvilke grænseflader er tilvejebragt.
Lad os derefter forstå Java Collection Hierarchy.
Java-samlingshierarki
Alle klasser og grænseflader, der vises i nedenstående Java Collection-hierarki, hører til 'java.util. *' - pakken.
Som vist i ovenstående diagram består Java Collection Hierarchy af forskellige klasser og grænseflader. Som du kan se, arver hver af klassen fra en grænseflade, og alle klasser og grænseflader arver igen fra en enkelt 'samling' -grænseflade.
Lad os diskutere nogle almindelige metoder i samlingsgrænsefladen sammen med en kort introduktion om hver af de klasser og grænseflader, der er vist i ovenstående hierarki.
Samlingsgrænseflade
Samlingsgrænsefladen er rodgrænsefladen. Alle klasser i samlingsrammen implementerer samlingsgrænsefladen. Dette betyder, at hver samling vil have de metoder, der er deklareret i Collection-grænsefladen.
Nogle af metoderne til samlingsgrænsefladen er angivet nedenfor.
| Ingen | Metode Prototype | Beskrivelse |
|---|---|---|
| 7 | standard boolsk removeIf (Predicate filter) | Fjern alle de elementer, der opfylder det givne prædikatfilter fra samlingen. |
| en | offentlig int-størrelse () | Returnerer antallet af elementer i en given samling. |
| to | offentlig tomrum klar () | Rydder samlingen ved at fjerne alle elementerne fra samlingen. |
| 3 | offentlig boolsk tilføjelse (E e) | Indsætter et element e i samlingen. |
| 4 | public booleanaddAll (Collection c) | Indsæt alle elementerne i samlingen givet af c i samlingen. |
| 5 | offentlig boolsk fjernelse (Objektelement) | Slet element givet af 'element' fra samlingen. |
| 6 | offentlig boolsk removeAll (Collectionc) | Fjern samlingen c fra samlingen. |
| 8 | public booleanretainAll (Collection c) | Slet alle elementer fra samlingen undtagen dem i den angivne samling c. |
| 9 | offentlig itterator iterator () | Returner iterator til samlingen. |
| 10 | offentlig Objekt () toArray () | Konverter samlingen til en matrix. |
| elleve | offentlig T () til Array (T () a) | Konverter samlingen til en matrix med en specificeret returtype. |
| 12 | offentlig boolsk isEmpty () | Returner, hvis samlingen er tom eller ikke. |
| 13 | offentlig boolsk indeholder (Objektelement) | Kontroller, om en samling indeholder det givne element (søgning). |
| 14 | public booleancontainsAll (Collectionc) | Kontroller, om samlingen indeholder den specificerede samling c inde i den. |
| femten | standard Spliterator spliterator () | Returnerer spliterator over en bestemt samling. |
| 16 | offentlige booleanequals (Objektelement) | Bruges til at matche to samlinger. |
| 17 | standard Stream parallelStream () | Returnerer parallel stream ved hjælp af samlingen som kilde. |
| 18 | standard Streamstream () | Returnerer sekventiel strøm ved hjælp af samlingen som kilde. |
| 19 | offentlig int hashCode () | Returnerer den numeriske hashkode for samlingen. |
Iterabel grænseflade
Den interterbare grænseflade er også basisgrænsefladen for samlingsrammen. Samlingsgrænsefladen, der er overordnet grænseflade til alle de andre klasser, udvider den interterbare grænseflade. Derfor implementerer alle klasser en samlingsgrænseflade såvel som en gentagelig grænseflade.
Den interaktive grænseflade har kun en metode iterator (), der returnerer iteratoren (), som du kan bruge til at gentage elementerne af typen T.
Iterator iterator ()Iterator-interface
Iterator-grænsefladen giver mulighed for at gentage elementerne i en fremadgående retning.
Følgende er de metoder, der understøttes af denne grænseflade.
| Ingen | Metode Prototype | Beskrivelse |
|---|---|---|
| en | offentlig Objekt næste () | Først returnerer elementet og flytter derefter markøren for at pege på det næste element. |
| to | offentlig boolsk hasNext () | Kontrollerer, om iteratoren har flere elementer. |
| 3 | offentlig tomrum fjern () | Fjerner det element, der til sidst returneres af iteratoren. |
Listegrænseflade
Listegrænsefladen arver samlingsgrænsefladen. Listegrænseflade indeholder datastrukturer, der bruges til at gemme bestilte data eller indsamling af objekter. Disse datastrukturer er af en listetype. Disse datastrukturer, der implementerer listegrænsefladen, har muligvis duplikatværdier.
Listegrænseflade indeholder de metoder, der bruges til at få adgang til, indsætte eller fjerne elementer fra listeobjekterne.
Forskellige klasser, der implementerer List-grænsefladen, er som følger:
bedste wow-server til nye spillere 2017
- ArrayList
- LinkedList
- Vektor
- Stak
Vi vil diskutere hver af disse klasser kort. Vores efterfølgende emner vil have en detaljeret diskussion om hver af samlingens rammeklasser.
# 1) ArrayList
ArrayList er den enkleste implementering af List-grænsefladen. ArrayList bevarer indsætningsrækkefølgen, og den synkroniseres ikke.
Den generelle definition af ArrayList-datastruktur (Collection) er som følger:
List list1= new ArrayList ();Når listen er defineret, kan du bruge 'tilføj'-metoden til at tilføje elementer. Bemærk, at internt anvendte ArrayList dynamisk array-mekanisme.
Se følgende eksempler, der opretter en ArrayList-samling af farver.
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:
Ovenstående program viser demonstrationen af ArrayList-samlingen. Vi tilføjer farveværdier til samlingen og krydser derefter samlingen for at vise individuelle værdier i samlingen ved hjælp af en iterator.
# 2) LinkedList
LinkedList-samlingen bruger internt en dobbeltkoblet listemekanisme til lagring af elementer. Det kan indeholde duplikatelementer. LinkedList-indsamlingsoperationer er hurtigere, da skift af elementer ikke er påkrævet.
Den generelle definition af oprettelse af en linket liste er som følger:
List list2 = new LinkedList ();Det følgende program demonstrerer den sammenkædede listeindsamling af nummernavne .
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 opretter vi en linket liste og tilføjer derefter elementer til den ved hjælp af 'tilføj'-metoden. Derefter krydser vi den sammenkædede liste ved hjælp af en iterator og viser hvert element.
# 3) Vektor
Vector ligner ArrayList og bruger et dynamisk array til at gemme elementerne som ArrayList. Men vektor understøtter mange uafhængige metoder bortset fra samlingen, der gør det til et bedre valg at være en foretrukken samling.
Den generelle definition for vektorindsamling er:
List list3 = new Vector();Bemærk, at selvom vektor og ArrayList bruger den samme mekanisme for dynamiske arrays, er vektorelementerne synkroniserede.
Nedenstående Java-program demonstrerer brugen af vektorer i samlingsrammen .
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 dette program har vi defineret en vektorsamling bestående af emner. Vi tilføjer forskellige emner og bruger derefter en iterator til at udsende elementerne.
# 4) Stak
Stak-datastruktur implementerer den sidste-i-første-ud (LIFO) måde at indsætte elementer på. Stakken er en underklasse af klassevektoren (se samlingshierarkidiagrammet ovenfor). Bortset fra sine egne metoder understøtter staksamlingen også metoderne til vektoropsamling.
Den generelle definition af Stack-samlingen er:
List list4 = new Stack();Det følgende program implementerer staksamling .
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 ovenstående implementering tilføjes de nye elementer til stakken ved hjælp af 'skubbe' operation. Stakken har et enkelt indgangspunkt kaldet 'Top of the stack', og elementerne skubbes på stakken øverst. Således er det sidste tilføjede element øverst i stakken.
Ligesom tilføjelse fjernes elementer også fra den ene ende, dvs. toppen af stakken. For at fjerne elementer bruges en operation 'pop'. Således, hvis du kalder pop (), fjernes elementet øverst i stakken.
I outputen ovenfor indsætter vi elementet 2, 4, 6,8,10 og kalder derefter pop (), så 10 fjernes.
Køinterface
Samlingerne, der stammer fra køgrænsefladen, følger FIFO-ordren (first-in-first-out). Elementerne indsættes i den ene ende og fjernes fra den anden ende. Derfor er det indtastede element tilfældigvis det element, der fjernes først.
Nedenfor er de samlinger, der understøtter forespørgselsgrænsefladen.
- PriorityQueue
- og interface
- ArrayDeque
Lad os diskutere hver af disse kort.
# 1) PriorityQueue
I PriorityQueue-samlingen behandles de lagrede elementer baseret på deres prioriteter. Du kan ikke gemme nulværdier i prioritetskøen.
Den generelle definition af prioritetskøen er som følger:
Queue q1 = new PriorityQueue();Nedenstående program implementerer prioritetskøen.
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:
Igen bruger vi farver som elementer i prioritetskøen. I ovenstående program har vi brugt metoderne tilføj og fjern for at tilføje elementer til køen og fjerne henholdsvis et element. Vi bruger peek () -metoden, der returnerer et element, det peger på i prioritetskøen.
Endelig ved hjælp af en iterator vises elementerne i prioritetskøen.
# 2) berøringsgrænseflade
Deque eller en 'dobbeltkø' er en datastruktur, der giver dig mulighed for at tilføje og fjerne elementerne fra begge ender. Deque-grænsefladen i Java-samlingsrammen, der udvider kø-grænsefladen.
Det giver funktionalitet af deque og har en klasse, som en 'ArrayDeque' arver fra den.
# 3) ArrayDeque
ArrayDeque implementerer deque-grænsefladen.
Den generelle definition af ArrayDeque er som følger:
Deque d = new ArrayDeque();ArrayDeque giver dig mulighed for at bruge Deques funktionalitet. I modsætning til andre samlinger som ArrayList eller stack har ArrayDeque ingen begrænsninger for dens kapacitet.
Følgende eksempel viser implementeringen af 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 ovenstående program definerer vi en ArrayDeque-samling af typen heltal og føjer heltalselementer til det ved hjælp af add-metoden. Samlingen krydses derefter ved hjælp af for konstruktionen.
Indstil grænseflade
Sætgrænsefladen er en del af pakken java.util og strækker sig fra samlingsgrænsefladen. Sæt er en struktur, der ikke tillader, at samlingen har duplikatværdier og også mere end en nulværdi.
Følgende klasser implementerer den indstillede grænseflade.
- HashSet
- LinkedHashSet
- TreeSet
# 1) HashSet
HashSet-samling, der implementerer Set-grænsefladen, har forskellige værdier, der er gemt i den. Denne samling bruger hashing-teknikken til at gemme varerne og bruger hash-tabellen til opbevaring af elementer.
T den generelle definition af HashSet-samlingen er vist nedenfor.
Set s1 = new HashSet();Vi har givet HashSet-implementeringen i det følgende 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 ovenstående program opretter vi en HashSet-samling af emner og krydser den derefter ved hjælp af en iterator for at vise elementerne i samlingen.
# 2) LinkedHashSet
LinkedHashSet implementerer en sæt grænseflade og udvider HashSet (henvis samlingshierarki). LinkedHashSet er den linkede listerepræsentation af grænsefladen Sæt. LinkedHashSet indeholder unikke elementer, men tillader nulværdier.
Den generelle definition af LinkedHashSet er angivet nedenfor.
Set s2 = new LinkedHashSet();Implementeringen til LinkedHashSet er angivet nedenfor.
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:
Endnu en gang bruger vi bogtitler til oprettelse af Linkedhashset. Som du kan se fra output, opretholdes rækkefølgen af tilføjelse af linkedHashSet.
hvordan man får hurtigbøger gratis
SortedSet Interface
SortedSet-grænsefladen muliggør fuldstændig ordning af elementer. Den indeholder metoder, der giver en naturlig rækkefølge af elementer. Elementer i samlingen, der implementerer SortedSet-grænsefladen, arrangeres i stigende rækkefølge.
TreeSet-klassen er et af eksemplerne, der implementerer SortedSet-grænsefladen.
Treeset
Den generelle definition af Treeset er som følger:
Set s3 = new TreeSet();TreeSet implementerer SortedSet-grænsefladen og indeholder unikke elementer. Opbevaring og hentning er ret hurtig, og derefter arrangeres elementerne i stigende rækkefølge.
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 ovenstående program oprettede vi og tilføjede ulige numre til samlingen ved hjælp af tilføjelsesmetoder. Derefter udlæser vi elementerne i samlingen ved hjælp af en iterator.
Fordele ved Java Collections Framework
- Reduceret programmering: Collections-rammen kommer med alle grænseflader og klasser, der indeholder de metoder, der kan gøre det muligt for programmører at skrive et effektivt program. På denne måde behøver programmøren ikke at fokusere på for meget programmering.
- Konsekvente metoder og API: Alle klasser har fælles metoder, der virker på data. Disse API'er er konsistente i alle klasser, og programmøren behøver ikke bekymre sig om at have for mange forskellige metoder til hver klasse.
- Forøg hastighed og nøjagtighed: Du kan skrive yderst effektive programmer ved hjælp af en indsamlingsramme og også hurtigere og nøjagtige programmer, da indsamlingsrammen giver den fulde funktionalitet til at implementere datastrukturer og samlinger.
- Gør det lettere at genbruge software: Datastrukturer og algoritmer i Java-indsamlingsrammen kan genbruges.
- Interoperabilitet blandt ikke-relaterede API'er: Samlings-API'er tillader interoperabilitet selv blandt ikke-relaterede API'er.
- Færre indsats for at designe nye API'er: Programmører kan bruge standardopsamlings-API'erne og designe nye API'er baseret på det. De behøver ikke at kæmpe for at skrive komplette nye API'er.
Ofte stillede spørgsmål
# 1) Hvad er brugen af en samlingsramme i Java?
Svar: Collection framework tilbyder forpakket algoritmer, grænseflader og klasser, der giver programmerere mulighed for at skrive meget effektive programmer, der kan gemme og behandle data.
# 2) Hvorfor indsamling er en ramme?
Svar: En ramme er en genanvendelig samling af klasser, grænseflader og algoritmer. Samlingsrammen er også en genanvendelig samling af datastrukturklasser og algoritmer, der fungerer på disse klasser.
# 3) Hvad er Java Collections API i Java?
Svar: Java collection API giver grænseflader og klasser, der kan udvides og implementeres for at bruge datastrukturer, der ikke er andet end samlinger.
# 4) Hvad er forskellen mellem samling og samlinger i Java?
Svar: Samlingen er en basisgrænseflade i samlingens ramme, mens 'samlinger' er en klasse. Begge er en del af java.util-pakken.
**** Flere detaljer og eksempler på Java Collections Framework: ****
Sammenligning mellem liste, sæt og kø:
| Liste | Sæt | Kø |
|---|---|---|
| Indsætningsrækkefølgen opretholdes | Indsætningsrækkefølgen opretholdes ikke i Hash-sæt | Indsætningsrækkefølgen opretholdes. |
| Kan indeholde duplikatelementer | Kan ikke indeholde duplikatelementer | Kan indeholde duplikatelementer. |
| Indsættelse og fjernelse af array kan gøres for ethvert indeks. | Fjern det angivne element. | Kun det sidst indsatte element kan poppes ud. Også indsættelse af elementer sker i slutningen. |
Array List Class
I Array er hukommelsestildelingen fast. Men i ArrayList kan hukommelse allokeres dynamisk. Denne ArrayList-klasse opretholder indsætningsrækkefølgen, og du kan indsætte duplikatelementer.
Demoprogram til matrixliste:
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-klasse
Linked List datastruktur indeholder noder, og denne node vil indeholde to dele:
- Data
- Henvisning til det næste element
Den første node er ikke en separat node. Den indeholder kun referencen og kaldes et hoved. Den sidste node er nul.
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ø er først ind først ud (FIFO) datastruktur. Hvis du kalder fjernelsesmetoden, fjernes altid det første indsatte element fra køen. Så kø bruges i realtidsapplikation, hvor dataene skal hentes i den indsatte rækkefølge.
Eksempel 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); } } 
Sæt
En samling af samlinger tillader ikke duplikatelementer. Du kan bruge en bestemt datastruktur, når du vil behandle indsamlingen af data uden duplikering, og når der ikke er behov for at opretholde indsætningsrækkefølgen.
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-interface
- Når du vil have procesopsamling af elementer med nøgle- og værdipar, kan du bruge kortdatastruktur, da kortet er et objekt, der kan kortlægge nøgler til værdier.
- Et kort kan ikke indeholde duplikatnøgler.
- De vigtige implementeringer af kort er HashMap, Treemap, LinkedHashMap, HashTable.
Forskel mellem HashMap, Treemap, LinkedHashMap og HashTable:
HashMap TreeMap LinkedHashmap HashTable Nulletaster og værdier er tilladt Kun nulværdier tilladt. Nul nøgler og værdier tilladt. Det tillader ikke nul-nøgler og værdier. Ikke synkroniseret Ikke synkroniseret Ikke synkroniseret synkroniseret Der er ingen garanti for at opretholde orden i iterationen Sortering foretages på baggrund af naturlig rækkefølge. Indsætningsrækkefølgen opretholdes Indsætningsrækkefølgen opretholdes ikke.
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); } } 
Nøglepunkter, der skal bemærkes:
- Liste, kø, sæt grænseflader udvider samlingsgrænsefladen, og denne samlingsgrænseflade har almindelige metoder som tilføj, fjern osv.
- Indsætningsrækkefølgen opretholdes på listen, og et sæt kan ikke indeholde duplikatelementer. Kø er første ind først ud datastruktur.
- Kortet indeholder nøgle- og værdipar. HashMap, Treemap, Hashtable, Linked HashMap er den vigtige implementering af kortgrænsefladen.
Konklusion
Denne vejledning gav os en introduktion til Java Collections Framework. Vi berørte kort alle klasser og grænseflader, der er en del af Java-samlingens ramme.
I vores efterfølgende tutorials i denne serie lærer vi detaljeret om hver af disse klasser og grænseflader.
Du kan udforske mere om refleksioner i JAVA i vores kommende tutorial !!!
PREV-vejledning | NÆSTE vejledning
Anbefalet læsning
- Java Reflection Tutorial med eksempler
- Dybdegående formørkelsesvejledninger til begyndere
- Java SWING Tutorial: Container, komponenter og håndtering af begivenheder
- JAVA-vejledning til begyndere: 100+ praktiske Java-videovejledninger
- Adgang modifikatorer i Java - vejledning med eksempler
- Java String med String Buffer og String Builder Tutorial
- Introduktion til Java-programmeringssprog - Videovejledning
- Agurk Selen Tutorial: Agurk Java Selen WebDriver Integration
