Opplæring i Java Collections Framework (JCF)

java collections framework tutorial

Prøv Instrumentet Vårt For Å Eliminere Problemer

Velg Operativsystemet Velg Et Projeksjonsprogram (Valgfritt)

Beskriv Problemet Ditt

Denne opplæringen forklarer Java Collections Framework (JCF) i detaljer sammen med Collection Hierarchy, Various Grensesnitt og fordelene med JCF:

Håper disse veltalende opplæringene om dette Java-serien for nybegynnere er veldig nyttige for å berike din kunnskap om Java.

Vår forrige opplæring orienterte mer om grunnleggende I / O-operasjoner i Java . I denne opplæringen vil vi lære mer om Java Collections Framework (JCF).

Java Collections Framework (JCF) inneholder grensesnitt, abstrakte klasser og klasser som kan gi arkitekturen til å lagre og manipulere en gruppe objekter.

Java Collections Framework

Hva du vil lære:

Video Tutorials On Java Collections Framework

Kunnskap om Arraylist i Java:

Sett grensesnitt og køgrensesnitt i Java med sanntidseksempler:

HashMap, TreeMap og HashTable i Java:

Så langt har vi sett variabler som lagrer forskjellige typer data. Dette er enestående enheter og er ikke veldig nyttige når du har store mengder data å lagre og håndtere. Som vi vet er data den viktigste komponenten i databehandling.

Søknaden din må kunne trekke ut og samle inn data, behandle den for å finne nyttig informasjon og også sende den frem og tilbake slik at den blir brukt effektivt for å nå løsningene.

I denne programvareverdenen lagrer vi dataene som må struktureres på en bestemt måte, slik at programvarene kan lagre, lese, behandle og til slutt levere resultatene. Dette gjøres ved hjelp av datastrukturer.

Nesten alle programmeringsspråk støtter datastrukturer. Datastrukturen kan defineres som en strukturert fremstilling av data. Programmeringsspråk gir API-funksjoner (Application Programming Interface) for å manipulere datastrukturene.

Behov for innsamlingsrammer

Før Java 1.2 støttet Java-programmeringsspråk datastrukturer som matriser, vektorer eller hasjetabeller. Å utføre operasjoner på disse datastrukturene var ikke lett, da det ikke var noe felles grensesnitt som fungerte på disse datastrukturene.

Programmerere pleide å finne det vanskelig å skrive algoritmer som ville fungere for alle datastrukturene og var et stort problem. Det var behov for et felles grensesnitt som ville fungere konsekvent på alle datastrukturer og også utføre operasjoner effektivt.

Senere kom Java med et samlingsrammeverk som er en gruppe klasser og grensesnitt som består av forskjellige operasjoner som kan utføres på datastrukturer.

I denne veiledningen for Java Collections vil vi diskutere Java Collections Framework generelt. Vi vil utforske hver av samlingskomponentene i våre kommende opplæringsprogrammer.

Java Collections Framework

Før vi definerer et Java Collections Framework, la oss bli kjent med betydningen av samling og et rammeverk.

En samling kan defineres som en gruppe objekter. En samling er vanligvis en enkelt enhet som består av mer enn ett objekt. Et rammeverk er en programvare som har et ferdig funksjonelt grensesnitt eller arkitektur, og som også inneholder et sett med klasser og grensesnitt som skal brukes med det medfølgende grensesnittet.

Et samlerammeverk er definert som en enhetlig, ferdig arkitektur bestående av nedenstående.

# 1) Algoritmer

Dette er metoder eller sett med utsagn som kan hjelpe programmerere med å søke, sortere og behandle innsamlede data. Samlingen leveres pakket med grensesnitt, klasser og algoritmer.

Applikasjonene som er utviklet ved å arve samlingsrammen har tilgang til disse algoritmene og bruker de allerede definerte metodene og prosedyrene.

# 2) Grensesnitt

Grensesnitt i Java gir abstraksjon av implementeringen, dvs. bruker grensesnitt, brukeren er ikke klar over detaljene i implementeringen, men kan bare se metodene og dataene som kreves for å skrive en applikasjon. Samlingsgrensesnittet har mange grensesnitt som kan implementeres av programmereren for å skrive sine egne klasser.

# 3) Klasser

Klassene for Collection Framework er datastrukturer som kan implementeres i et program. Disse klassene implementerer 'Collection' -grensesnittet og arver dermed alle metodene og definisjonene av samlingsgrensesnittet.

Et samlingsrammeverk brukes til å lagre og manipulere samlingen som er gruppen av objekter.

Java-samlingsrammeverket består av algoritmer med høy ytelse som utfører standardoperasjoner som søk, sortering og behandling. Det gir forskjellige standardimplementeringer, inkludert LinkedList, TreeSet og HashSet som grensesnittene har.

La oss nå forstå Java Collection Hierarchy.

Java Collection Hierarchy

Alle klassene og grensesnittene som vises i nedenstående Java Collection-hierarki tilhører pakken “java.util. *”.

Java samling hierarki

Som vist i diagrammet ovenfor, består Java Collection Hierarchy av forskjellige klasser og grensesnitt. Som du kan se, arver hver klasse fra et grensesnitt, og alle klassene og grensesnittene arver i sin tur fra et enkelt 'samlingsgrensesnitt'.

La oss diskutere noen vanlige metoder i samlingsgrensesnittet sammen med en kort introduksjon om hver av klassene og grensesnittene som er vist i ovennevnte hierarki.

Samlingsgrensesnitt

Samlingsgrensesnittet er rotgrensesnittet. Alle klassene i samlingsrammeverket implementerer samlingsgrensesnittet. Dette betyr at hver samling vil ha metodene deklarert i Collection-grensesnittet.

Noen av metodene for samlingsgrensesnittet er gitt nedenfor.

Ikke	Metode Prototype	Beskrivelse
7	standard boolsk removeIf (Predicate filter)	Fjern alle elementene som tilfredsstiller det gitte predikatfilteret fra samlingen.
1	offentlig int størrelse ()	Returnerer antall elementer i en gitt samling.
to	offentlig tomrom ()	Fjerner samlingen ved å fjerne alle elementene fra samlingen.
3	offentlig boolsk tillegg (E e)	Setter inn et element e i samlingen.
4	public booleanaddAll (Collection c)	Sett inn alle elementene i samlingen gitt av c i samlingen.
5	offentlig boolsk fjern (objektelement)	Slett element gitt av ‘element’ fra samlingen.
6	offentlig boolsk removeAll (Collectionc)	Fjern samlingen c fra samlingen.
8	public booleanretainAll (Collection c)	Slett alle elementene fra samlingen unntatt de i den angitte samlingen c.
9	offentlig itterator iterator ()	Returner iterator for samlingen.
10	offentlig Objekt () toArray ()	Konverter samlingen til en matrise.
elleve	offentlig T () til Array (T () a)	Konverter samlingen til en matrise med en spesifisert returtype.
12	offentlig boolsk isEmpty ()	Returner hvis samlingen er tom eller ikke.
1. 3	offentlig boolsk inneholder (Objektelement)	Sjekk om en samling inneholder det gitte elementet (søkeoperasjon).
14	public booleancontainsAll (Collectionc)	Sjekk om samlingen inneholder spesifisert samling c inne i den.
femten	standard Spliterator spliterator ()	Returnerer spliterator over en spesifisert samling.
16	offentlige booleanequals (Objektelement)	Brukes til å matche to samlinger.
17	standard Stream parallelStream ()	Returnerer parallell strøm ved å bruke samlingen som kilde.
18	standard Streamstream ()	Returnerer sekvensiell strøm ved hjelp av samlingen som kilde.
19	offentlig int hashCode ()	Returnerer den numeriske hashkoden for samlingen.

Iterabelt grensesnitt

Iterable-grensesnittet er også basisgrensesnittet for samlingsrammeverket. Samlingsgrensesnittet som er overordnet grensesnitt for alle de andre klassene, utvider Iterable-grensesnittet. Derfor implementerer alle klassene et samlingsgrensesnitt så vel som et omgjørbart grensesnitt.

Iterable-grensesnittet har bare en metode iterator () som returnerer iteratoren () som du kan bruke til å iterere over elementene av typen T.

Iterator iterator ()

Iterator-grensesnitt

Iterator-grensesnittet gir muligheten til å iterere over elementene i en fremoverretning.

Følgende er metodene som støttes av dette grensesnittet.

Ikke	Metode Prototype	Beskrivelse
1	offentlig gjenstand neste ()	Først returnerer elementet og deretter flytter markøren for å peke til neste element.
to	offentlig boolsk hasNext ()	Sjekker om iteratoren har flere elementer.
3	offentlig tom fjern ()	Fjerner elementet som returneres av iteratoren til slutt.

Listegrensesnitt

Listegrensesnittet arver samlingsgrensesnittet. Listegrensesnitt inneholder datastrukturene som brukes til å lagre bestilte data eller samling av objekter. Disse datastrukturene er av listetype. Disse datastrukturene som implementerer listegrensesnittet, kan ha duplikatverdier eller ikke.

Listegrensesnitt inneholder metodene som brukes til å få tilgang til, sette inn eller fjerne elementer fra listeobjektene.

Ulike klasser som implementerer List-grensesnittet er som følger:

hvordan åpne torrentfiler på mac

ArrayList
LinkedList
Vector
Stable

Vi vil diskutere hver av disse klassene kort. Våre påfølgende emner vil ha en detaljert diskusjon om hver av rammeklassene for samlingen.

# 1) ArrayList

ArrayList er den enkleste implementeringen av grensesnittet List. ArrayList bevarer innsettingsrekkefølgen, og den synkroniseres ikke.

Den generelle definisjonen av ArrayList datastruktur (Collection) er som følger:

List list1= new ArrayList ();

Når listen er definert, kan du bruke 'legg til' metoden for å legge til elementer. Merk at internt brukte ArrayList dynamisk array-mekanisme.

Se følgende eksempler som lager en ArrayList-samling av farger.

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

Produksjon:

ArrayList

Ovennevnte program viser demonstrasjonen av ArrayList-samlingen. Vi legger til fargeverdier i samlingen og krysser deretter samlingen for å vise individuelle verdier i samlingen ved hjelp av en iterator.

# 2) LinkedList

LinkedList-samlingen bruker internt en dobbelt koblet listemekanisme for lagring av elementer. Den kan inneholde dupliserte elementer. LinkedList-innsamlingsoperasjoner er raskere ettersom det ikke er nødvendig å skifte elementer.

Den generelle definisjonen av å lage en koblet liste er som følger:

List list2 = new LinkedList ();

Følgende program demonstrerer den koblede listen samlingen av nummernavn .

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

Produksjon:

LinkedList

Dermed lager vi en koblet liste og legger deretter til elementer i den ved hjelp av ‘add’ metoden. Deretter bruker vi en iterator, krysser vi den koblede listen og viser hvert element.

# 3) Vektor

Vector ligner på ArrayList og bruker en dynamisk matrise til å lagre elementene som ArrayList. Men vektor støtter mange uavhengige metoder bortsett fra samlingen som gjør det til et bedre valg å være en foretrukket samling.

Den generelle definisjonen for vektorsamling er:

List list3 = new Vector();

Merk at selv om vektor og ArrayList bruker den samme mekanismen for dynamiske matriser, er vektorelementene synkronisert.

Java-programmet gitt nedenfor viser bruken av 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()); } } }

Produksjon:

Vector

I dette programmet har vi definert en vektorsamling som består av fag. Vi legger til forskjellige emner og bruker deretter en iterator for å sende elementene.

# 4) Stakk

Stakk datastruktur implementerer den siste inn-først ut (LIFO) måten å sette inn elementer. Stakken er en underklasse av klassevektoren (se samlehierarkidiagrammet ovenfor). Bortsett fra sine egne metoder, støtter stablesamlingen også metodene for vektorinnsamling.

Den generelle definisjonen av Stack-samlingen er:

List list4 = new Stack();

Følgende program implementerer 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() + ' '); } } }

Produksjon:

Stack samling

Som du kan se i implementeringen ovenfor, legges de nye elementene til stabelen ved å bruke 'trykk' operasjon. Bunken har et enkelt inngangspunkt kalt 'Top of stack' og elementene skyves på stabelen øverst. Dermed er det siste elementet som er lagt til øverst i bunken.

Som å legge til, fjernes også elementer fra den ene enden, dvs. toppen av stabelen. For å fjerne elementer brukes en operasjon ‘pop’. Dermed hvis du kaller pop (), blir elementet øverst i bunken fjernet.

I utgangen ovenfor setter vi inn elementet 2, 4, 6,8,10 og kaller deretter pop () slik at 10 blir fjernet.

Køgrensesnitt

Samlingene avledet fra køgrensesnittet følger bestillingen først-i-først-ut (FIFO). Elementene settes inn i den ene enden og fjernes fra den andre enden. Derfor er elementet som først ble skrevet inn tilfeldigvis det elementet som fjernes først.

Nedenfor er samlingene som støtter søkegrensesnittet.

PriorityQueue
og grensesnitt
ArrayDeque

La oss diskutere hver av disse kort.

# 1) PriorityQueue

I PriorityQueue-samlingen behandles elementene som er lagret basert på deres prioriteringer. Du kan ikke lagre nullverdier i prioritetskøen.

Den generelle definisjonen av prioritetskøen er som følger:

Queue q1 = new PriorityQueue();

Programmet nedenfor 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() + ' '); } } }

Produksjon:

PriorityQueue

Nok en gang bruker vi farger som elementer i prioritetskøen. I det ovennevnte programmet har vi brukt metodene legge til og fjerne for å legge til elementer i køen og fjerne et element henholdsvis. Vi bruker peek () -metoden som returnerer et element det peker på i prioritetskøen.

Til slutt ved hjelp av en iterator vises elementene i prioritetskøen.

# 2) berøringsgrensesnitt

Deque eller en 'dobbeltkø' er en datastruktur som lar deg legge til og fjerne elementene fra begge ender. Deque-grensesnittet i Java-samlingsrammeverket som utvider køgrensesnittet.

Det gir funksjonaliteten til deque og har en klasse som en 'ArrayDeque' arver fra den.

# 3) ArrayDeque

ArrayDeque implementerer deque-grensesnittet.

Den generelle definisjonen av ArrayDeque er som følger:

Deque d = new ArrayDeque();

ArrayDeque lar deg bruke funksjonaliteten til Deque. I motsetning til andre samlinger som ArrayList eller stack, har ArrayDeque ingen begrensninger på kapasiteten.

Følgende eksempel viser 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); } } }

Produksjon:

ArrayDeque

I det ovennevnte programmet definerer vi en ArrayDeque-samling av type heltall og legger til heltallelementer til det ved hjelp av add-metoden. Samlingen krysses deretter ved hjelp av for konstruksjonen.

Sett grensesnitt

Settgrensesnittet er en del av pakken java.util og strekker seg fra samlingsgrensesnittet. Sett er en struktur som ikke tillater at samlingen har dupliserte verdier og også mer enn én nullverdi.

Følgende klasser implementerer det angitte grensesnittet.

HashSet
LinkedHashSet
TreeSet

# 1) HashSet

HashSet-samlingen som implementerer Set-grensesnittet, har forskjellige verdier som er lagret i den. Denne samlingen bruker hashing-teknikken til å lagre varene og bruker hash-tabellen til å lagre elementer.

T den generelle definisjonen av HashSet-samlingen er vist nedenfor.

Set s1 = new HashSet();

Vi har gitt HashSet-implementeringen i det følgende programmet.

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

Produksjon:

HashSet

I det ovennevnte programmet oppretter vi en HashSet-samling av emner og krysser den deretter ved hjelp av en iterator for å vise elementene i samlingen.

# 2) LinkedHashSet

LinkedHashSet implementerer et settgrensesnitt og utvider HashSet (henvis samlingshierarkiet). LinkedHashSet er den lenkede representasjonen av grensesnittet Set. LinkedHashSet inneholder unike elementer, men tillater nullverdier.

Den generelle definisjonen av LinkedHashSet er gitt nedenfor.

Set s2 = new LinkedHashSet();

Implementeringen for LinkedHashSet er gitt 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()); } } }

Produksjon:

LinkedHashSet

Nok en gang bruker vi boktitler for å lage Linkedhashset. Som du kan se fra utdataene, opprettholdes rekkefølgen for tillegg av linkedHashSet.

SortedSet-grensesnitt

SortedSet-grensesnittet tillater fullstendig bestilling av elementer. Den inneholder metoder som gir en naturlig ordning av elementer. Elementer i samlingen som implementerer SortedSet-grensesnittet ordnes i økende rekkefølge.

TreeSet-klassen er et av eksemplene som implementerer SortedSet-grensesnittet.

hva er nettverksnøkkel for wifi

Treeset

Den generelle definisjonen av Treeset er som følger:

Set s3 = new TreeSet();

TreeSet implementerer SortedSet-grensesnittet og inneholder unike elementer. Lagring og henting er ganske rask, og deretter ordnes elementene i stigende rekkefø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() + ' '); } } }

Produksjon:

Treeset

I det ovennevnte programmet opprettet vi og la til oddetall i samlingen ved å legge til metoder. Deretter bruker vi en iterator og sender ut elementene i samlingen.

Fordeler med Java Collections Framework

Redusert programmering: Collections-rammeverket kommer med alle grensesnittene og klassene som inneholder metodene som lar programmerere skrive et effektivt program. På denne måten trenger ikke programmereren å fokusere på for mye programmering.
Konsekvente metoder og API: Alle klassene har vanlige metoder som virker på data. Disse API-ene er konsistente gjennom klassene, og programmereren trenger ikke å bekymre seg for å ha for mange forskjellige metoder for hver klasse.
Øk hastighet og nøyaktighet: Du kan skrive svært effektive programmer ved hjelp av et samlingsrammeverk og også raskere og nøyaktige programmer, da samlingsrammeverket gir full funksjonalitet for å implementere datastrukturer og samlinger.
Forenkler gjenbruk av programvare: Datastrukturer og algoritmer for Java-samlingsrammeverket er gjenbrukbare.
Interoperabilitet blant ikke-relaterte APIer: Samlings-API-er tillater interoperabilitet selv blant ikke-relaterte API-er.
Færre innsats for å designe nye APIer: Programmører kan bruke standard samling APIer og designe nye APIer basert på det. De trenger ikke å slite med å skrive helt nye API-er.

ofte stilte spørsmål

# 1) Hva er bruken av et samlerammeverk i Java?

Svar: Collection framework tilbyr forhåndspakkede algoritmer, grensesnitt og klasser som lar programmerere skrive svært effektive programmer som kan lagre og behandle data.

# 2) Hvorfor er samling et rammeverk?

Svar: Et rammeverk er en gjenbrukbar samling av klasser, grensesnitt og algoritmer. Samlingsrammeverket er også en gjenbrukbar samling av datastrukturklasser og algoritmer som fungerer på disse klassene.

# 3) Hva er Java Collections API i Java?

Svar: Java Collections API gir grensesnitt og klasser som kan utvides og implementeres for å bruke datastrukturer som ikke er annet enn samlinger.

# 4) Hva er forskjellen mellom samling og samlinger i Java?

Svar: Samlingen er et basisgrensesnitt i samlingsrammeverket mens ‘samlinger’ er en klasse. Begge deler er en del av java.util-pakken.

**** Flere detaljer og eksempler på Java Collections Framework: ****

Java Collection-grensesnitt

Sammenligning mellom liste, sett og kø:

Liste	Sett	Kø
Innføringsrekkefølgen opprettholdes	Innføringsrekkefølgen opprettholdes ikke i Hash-settet	Innføringsrekkefølgen opprettholdes.
Kan inneholde dupliserte elementer	Kan ikke inneholde dupliserte elementer	Kan inneholde dupliserte elementer.
Innsetting og fjerning av matrisen kan gjøres for hvilken som helst indeks.	Fjern det angitte elementet.	Bare det sist innsatte elementet kan poppes ut. Også, innsetting av elementer skjer på slutten.

Array List Class

I Array er minnetildelingen løst. Men i ArrayList kan minne tildeles dynamisk. Denne ArrayList-klassen opprettholder innsettingsrekkefølgen, og du kan sette inn dupliserte elementer.

Demoprogram for matriseliste:

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

Array List Class

LinkedList-klasse

Koblet liste datastruktur inneholder noder og denne noden vil inneholde to deler:

Data
Henvisning til neste element

Den første noden er ikke en egen node. Den inneholder bare referansen og kalles et hode. Den siste noden er null.

Koblet listeklasse

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 inn først ut (FIFO) datastruktur. Hvis du kaller fjerningsmetoden, vil alltid det første innsatte elementet bli fjernet fra køen. Så kø brukes i sanntidsapplikasjon der dataene må hentes i den innsatte rekkefølgen.
  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); } }  
  Sett 
 En samling samling tillater ikke dupliserte elementer. Du kan bruke en angitt datastruktur, når du vil behandle innsamlingen av data uten duplisering, og når det ikke er behov for å opprettholde innsettingsrekkefø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-grensesnitt 
  Når du vil ha prosessinnsamling av elementer med nøkkel- og verdiparet, kan du bruke kartdatastruktur, da kartet er et objekt som kan kartlegge nøkler til verdier.
 Et kart kan ikke inneholde dupliserte nøkler.
 De viktige implementeringene av kart er HashMap, Treemap, LinkedHashMap, HashTable.
 
  Forskjellen mellom HashMap, Treemap, LinkedHashMap og HashTable: 
   HashMap TreeMap LinkedHashmap HashTable  
 
   
  Nulltaster og verdier er tillatt Bare nullverdier tillatt. Nulltaster og verdier tillatt. Det tillater ikke nulltaster og verdier.  
  Ikke synkronisert Ikke synkronisert Ikke synkronisert synkronisert  
  Det er ingen garanti for å opprettholde orden i iterasjonen Sortering vil bli gjort basert på naturlig rekkefølge. Innføringsrekkefølgen vil bli opprettholdt Innføringsrekkefølgen opprettholdes 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); } }  
  Viktige punkter som skal bemerkes: 
  Liste, kø, sett grensesnitt utvider samlingsgrensesnittet, og dette samlingsgrensesnittet har vanlige metoder som å legge til, fjerne osv.
 Innføringsrekkefølgen opprettholdes i listen, og et sett kan ikke inneholde dupliserte elementer. Kø er først inn først ut datastruktur.
 Kartet vil inneholde nøkkel- og verdipar. HashMap, Treemap, Hashtable, Linked HashMap er den viktige implementeringen av kartgrensesnittet.
 
 Konklusjon
 Denne opplæringen ga oss en introduksjon til Java Collections Framework. Vi berørte kort alle klassene og grensesnittene som er en del av Java-samlingsrammeverket.
 I våre påfølgende opplæringsprogrammer i denne serien vil vi lære i detalj om hver av disse klassene og grensesnittene.
   Du kan utforske mer om refleksjoner i JAVA i vår kommende opplæring !!!  
   PREV Opplæring | NESTE veiledning  
  Anbefalt lesing
    Java Reflection Tutorial med eksempler  
  In-Depth Eclipse Tutorials For Beginners  
  Java SWING Tutorial: Container, Components and Event Handling  
  JAVA-opplæring for nybegynnere: 100+ praktiske Java-videoveiledninger  
  Få tilgang til modifikatorer i Java - opplæring med eksempler  
  Java String with String Buffer and String Builder Tutorial  
  Introduksjon til Java Programming Language - Video Tutorial  
  Agurk Selen Tutorial: Agurk Java Selen WebDriver Integration