logo

Samlinger i Java

Enhver gruppe av individuelle objekter som er representert som en enkelt enhet er kjent som en Java-samling av objekter. I Java, et eget rammeverk kalt Innsamlingsramme har blitt definert i JDK 1.2 som inneholder alle Java Collection-klassene og grensesnittet.

I Java, samlingsgrensesnittet ( java.util. Collection ) og kartgrensesnitt ( java.util.Map ) er de to hovedrotgrensesnittene til Java-samlingsklasser.



Hva du bør lære i Java-samlinger?

  • Listegrensesnitt
  • Køgrensesnitt
    • Grensesnitt for blokkering av kø
    • Abstrakt kø-klasse
    • Prioritetskøklasse
    • PriorityBlockingQueue Class
    • ConcurrentLinkedQueue Class
    • ArrayBlockingQueue Class
    • DelayQueue Class
    • LinkedBlockingQueue Class
    • LinkedTransferQueue
  • Og grensesnittet
    • BlockingDeque-grensesnitt
    • ConcurrentLinkedDeque-klasse
    • ArrayDeque klasse
  • Angi grensesnitt
    • Abstrakt sett klasse
    • CopyOnWriteArraySet Class
    • EnumSet Class
    • ConcurrentHashMap Class
    • HashSet-klasse
    • LinkedHashSet Class
  • SortedSet-grensesnitt
    • NavigableSet-grensesnitt
    • Tresett
    • ConcurrentSkipListSet Class
  • Kartgrensesnitt
    • SortedMap-grensesnitt
    • NavigableMap-grensesnitt
    • ConcurrentMap-grensesnitt
    • TreeMap klasse
    • Abstrakt kartklasse
    • ConcurrentHashMap Class
    • EnumMap Class
    • HashMap-klasse
    • IdentityHashMap Class
    • LinkedHashMap Class
    • HashTable-klasse
    • Eiendomsklasse
  • Andre viktige konsepter
    • Hvordan konvertere HashMap til ArrayList
    • Velg tilfeldig elementer fra en liste
    • Hvordan legge til alle elementer fra en samling til en ArrayList
    • Konvertering av Java Maps til List
    • Konvertering fra Array til ArrayList
    • Konvertering fra ArrayList til Array
    • Forskjeller mellom Array og ArrayList

Hva er et rammeverk i Java?

Et rammeverk er et sett med klasser og grensesnitt som gir en ferdiglaget arkitektur. For å implementere en ny funksjon eller en klasse, er det ikke nødvendig å definere et rammeverk. En optimal objektorientert design inkluderer imidlertid alltid et rammeverk med en samling av klasser slik at alle klassene utfører samme type oppgave.

Behov for et separat samlingsrammeverk i Java

Før Collection Framework (eller før JDK 1.2) ble introdusert, var standardmetodene for gruppering av Java-objekter (eller samlinger) Matriser eller Vektorer , eller hashtabeller . Alle disse samlingene hadde ikke noe felles grensesnitt. Derfor, selv om hovedmålet for alle samlingene er det samme, ble implementeringen av alle disse samlingene definert uavhengig og hadde ingen sammenheng mellom dem. Og også, det er veldig vanskelig for brukerne å huske alle de forskjellige metoder , syntaks og konstruktører til stede i hver samlingsklasse.
La oss forstå dette med et eksempel på å legge til et element i en hashtabell og en vektor.



maskinlæringsmodeller

Eksempel:

Java






// Java program to demonstrate> // why collection framework was needed> import> java.io.*;> import> java.util.*;> class> CollectionDemo {> >public> static> void> main(String[] args)> >{> >// Creating instances of the array,> >// vector and hashtable> >int> arr[] =>new> int>[] {>1>,>2>,>3>,>4> };> >Vector v =>new> Vector();> >Hashtable h =>new> Hashtable();> >// Adding the elements into the> >// vector> >v.addElement(>1>);> >v.addElement(>2>);> >// Adding the element into the> >// hashtable> >h.put(>1>,>'geeks'>);> >h.put(>2>,>'4geeks'>);> >// Array instance creation requires [],> >// while Vector and hastable require ()> >// Vector element insertion requires addElement(),> >// but hashtable element insertion requires put()> >// Accessing the first element of the> >// array, vector and hashtable> >System.out.println(arr[>0>]);> >System.out.println(v.elementAt(>0>));> >System.out.println(h.get(>1>));> >// Array elements are accessed using [],> >// vector elements using elementAt()> >// and hashtable elements using get()> >}> }>

>

>

Produksjon

1 1 geeks>

Som vi kan observere, implementerer ingen av disse samlingene (Array, Vector eller Hashtable) et standard medlemstilgangsgrensesnitt, det var veldig vanskelig for programmerere å skrive algoritmer som kan fungere for alle typer samlinger. En annen ulempe er at de fleste 'Vector'-metodene er endelige, noe som betyr at vi ikke kan utvide 'Vector'-klassen til å implementere en lignende type samling. Derfor bestemte Java-utviklere seg for å komme opp med et felles grensesnitt for å håndtere de ovennevnte problemene og introduserte Collection Framework i JDK 1.2-posten som både eldre vektorer og hashtabeller ble modifisert for å samsvare med Collection Framework.

Fordeler med Java Collection Framework

Siden mangelen på et innsamlingsrammeverk ga opphav til ovennevnte sett med ulemper, er følgende fordeler med innsamlingsrammeverket.

  1. Konsekvent API: API-en har et grunnleggende sett med grensesnitt som Samling , Sett , Liste , eller Kart , alle klassene (ArrayList, LinkedList, Vector, etc) som implementerer disse grensesnittene har noen felles sett med metoder.
  2. Reduserer programmeringsinnsats: En programmerer trenger ikke å bekymre seg for utformingen av samlingen, men han kan heller fokusere på den beste bruken i programmet sitt. Derfor har det grunnleggende konseptet med objektorientert programmering (dvs.) abstraksjon blitt implementert.
  3. Øker programhastighet og kvalitet: Øker ytelsen ved å tilby høyytelsesimplementeringer av nyttige datastrukturer og algoritmer fordi programmereren i dette tilfellet ikke trenger å tenke på den beste implementeringen av en spesifikk datastruktur. Han kan ganske enkelt bruke den beste implementeringen for å drastisk øke ytelsen til algoritmen/programmet hans.

Hierarki av samlingsrammeverket i Java

Verktøypakken, (java.util) inneholder alle klassene og grensesnittene som kreves av samlingsrammeverket. Samlingsrammeverket inneholder et grensesnitt kalt et iterabelt grensesnitt som gir iteratoren til å iterere gjennom alle samlingene. Dette grensesnittet utvides av hovedsamlingsgrensesnittet som fungerer som en rot for samlingsrammeverket. Alle samlingene utvider dette samlingsgrensesnittet og utvider dermed egenskapene til iteratoren og metodene til dette grensesnittet. Følgende figur illustrerer hierarkiet til samlingsrammeverket.

Før vi forstår de forskjellige komponentene i rammeverket ovenfor, la oss først forstå en klasse og et grensesnitt.

  • Klasse : En klasse er en brukerdefinert blåkopi eller prototype som objekter opprettes fra. Det representerer settet med egenskaper eller metoder som er felles for alle objekter av én type.
  • Grensesnitt : Som en klasse kan et grensesnitt ha metoder og variabler, men metodene som er deklarert i et grensesnitt er som standard abstrakte (bare metodesignatur, ingen). Grensesnitt spesifiserer hva en klasse må gjøre og ikke hvordan. Det er klassens blåkopi.

Metoder for innsamlingsgrensesnittet

Dette grensesnittet inneholder ulike metoder som kan brukes direkte av alle samlingene som implementerer dette grensesnittet. De er:

Metode

Beskrivelse

add(Objekt) Denne metoden brukes til å legge til et objekt i samlingen.
addAll(Samling c) Denne metoden legger til alle elementene i den gitte samlingen til denne samlingen.
klar() Denne metoden fjerner alle elementene fra denne samlingen.
inneholder(Objekt o) Denne metoden returnerer true hvis samlingen inneholder det angitte elementet.
inneholder alle (samling c) Denne metoden returnerer sann hvis samlingen inneholder alle elementene i den gitte samlingen.
lik (Objekt o) Denne metoden sammenligner det angitte objektet med denne samlingen for likhet.
hashkode() Denne metoden brukes til å returnere hash-kodeverdien for denne samlingen.
er tom() Denne metoden returnerer true hvis denne samlingen ikke inneholder noen elementer.
iterator() Denne metoden returnerer en iterator over elementene i denne samlingen.
maks()
Denne metoden brukes til å returnere den maksimale verdien som finnes i samlingen.
parallelStream() Denne metoden returnerer en parallell strøm med denne samlingen som kilde.
fjern (Objekt o) Denne metoden brukes til å fjerne det gitte objektet fra samlingen. Hvis det er dupliserte verdier, fjerner denne metoden den første forekomsten av objektet.
removeAll(Samling c) Denne metoden brukes til å fjerne alle objektene som er nevnt i den gitte samlingen fra samlingen.
removeIf(Predikatfilter) Denne metoden brukes til å fjerne alle elementene i denne samlingen som tilfredsstiller gitt predikat .
retainAll(Samling c) Denne metoden brukes til å beholde bare elementene i denne samlingen som finnes i den angitte samlingen.
størrelse() Denne metoden brukes til å returnere antall elementer i samlingen.
splitter() Denne metoden brukes til å lage en Spliterator over elementene i denne samlingen.
strøm() Denne metoden brukes til å returnere en sekvensiell strøm med denne samlingen som kilde.
toArray() Denne metoden brukes til å returnere en matrise som inneholder alle elementene i denne samlingen.

Grensesnitt som utvider Java Collections-grensesnittet

Samlingsrammeverket inneholder flere grensesnitt der hvert grensesnitt brukes til å lagre en bestemt type data. Følgende er grensesnittene som finnes i rammeverket.

1. Iterable grensesnitt

Dette er rotgrensesnittet for hele samlingsrammeverket. Samlingsgrensesnittet utvider det iterable grensesnittet. Derfor implementerer alle grensesnittene og klassene dette grensesnittet. Hovedfunksjonen til dette grensesnittet er å gi en iterator for samlingene. Derfor inneholder dette grensesnittet bare én abstrakt metode som er iteratoren. Den returnerer

Iterator iterator();>

2. Innsamlingsgrensesnitt

Dette grensesnittet utvider det iterable grensesnittet og implementeres av alle klassene i samlingsrammeverket. Dette grensesnittet inneholder alle de grunnleggende metodene som hver samling har som å legge til dataene i samlingen, fjerne dataene, slette dataene osv. Alle disse metodene er implementert i dette grensesnittet fordi disse metodene implementeres av alle klassene uavhengig av stilen deres. av gjennomføringen. Og også, å ha disse metodene i dette grensesnittet sikrer at navnene på metodene er universelle for alle samlingene. Derfor kan vi kort sagt si at dette grensesnittet bygger et grunnlag som samlingsklassene implementeres på.

3. Listegrensesnitt

Dette er et underordnet grensesnitt til samlingsgrensesnittet. Dette grensesnittet er dedikert til data av listetypen der vi kan lagre alle de bestilte samlingene av objektene. Dette tillater også dupliserte data å være tilstede i den. Dette listegrensesnittet er implementert av forskjellige klasser som ArrayList, Vector, Stack, etc. Siden alle underklassene implementerer listen, kan vi instansiere et listeobjekt med hvilken som helst av disse klassene.

For eksempel:

List al = new ArrayList ();  List ll = new LinkedList ();  List v = new Vector ();  Where T is the type of the object>

Klassene som implementerer List-grensesnittet er som følger:

Jeg). ArrayList

ArrayList gir oss dynamiske matriser i Java. Skjønt, det kan være tregere enn standard arrays, men kan være nyttig i programmer der mye manipulasjon i arrayen er nødvendig. Størrelsen på en ArrayList økes automatisk hvis samlingen vokser eller krymper hvis objektene fjernes fra samlingen. Java ArrayList lar oss få tilgang til listen tilfeldig. ArrayList kan ikke brukes til innpakningsklasse for slike tilfeller.

La oss forstå ArrayList med følgende eksempel:

Java




// Java program to demonstrate the> // working of ArrayList> import> java.io.*;> import> java.util.*;> class> GFG {> >// Main Method> >public> static> void> main(String[] args)> >{> >// Declaring the ArrayList with> >// initial size n> >ArrayList al =>new> ArrayList();> >// Appending new elements at> >// the end of the list> >for> (>int> i =>1>; i <=>5>; i++)> >al.add(i);> >// Printing elements> >System.out.println(al);> >// Remove element at index 3> >al.remove(>3>);> >// Displaying the ArrayList> >// after deletion> >System.out.println(al);> >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(al.get(i) + ' '); } }>

>

>

Produksjon

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

ii). LinkedList

LinkedList-klassen er en implementering av La oss forstå LinkedList med følgende eksempel:

Java




// Java program to demonstrate the> // working of LinkedList> import> java.io.*;> import> java.util.*;> class> GFG {> >// Main Method> >public> static> void> main(String[] args)> >{> >// Declaring the LinkedList> >LinkedList ll =>new> LinkedList();> >// Appending new elements at> >// the end of the list> >for> (>int> i =>1>; i <=>5>; i++)> >ll.add(i);> >// Printing elements> >System.out.println(ll);> >// Remove element at index 3> >ll.remove(>3>);> >// Displaying the List> >// after deletion> >System.out.println(ll);> >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(ll.get(i) + ' '); } }>

>

>

Produksjon

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

iii). Vektor

En vektor gir oss dynamiske matriser i Java. Skjønt, det kan være tregere enn standard arrays, men kan være nyttig i programmer der mye manipulasjon i arrayen er nødvendig. Dette er identisk med ArrayList når det gjelder implementering. Den primære forskjellen mellom en vektor og en ArrayList er imidlertid at en Vector er synkronisert og en ArrayList er ikke-synkronisert.

La oss forstå vektoren med et eksempel:

Java




// Java program to demonstrate the> // working of Vector> import> java.io.*;> import> java.util.*;> class> GFG {> >// Main Method> >public> static> void> main(String[] args)> >{> >// Declaring the Vector> >Vector v =>new> Vector();> >// Appending new elements at> >// the end of the list> >for> (>int> i =>1>; i <=>5>; i++)> >v.add(i);> >// Printing elements> >System.out.println(v);> >// Remove element at index 3> >v.remove(>3>);> >// Displaying the Vector> >// after deletion> >System.out.println(v);> >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(v.get(i) + ' '); } }>

>

>

Produksjon

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

iv). Stable

Stable klassemodeller og implementerersist-inn-først-ut. I tillegg til de grunnleggende push- og pop-operasjonene, tilbyr klassen ytterligere tre funksjoner, tøm, søk og kikk. Klassen kan også refereres til som underklassen til Vector.

La oss forstå stabelen med et eksempel:

Java




// Java program to demonstrate the> // working of a stack> import> java.util.*;> public> class> GFG {> >// Main Method> >public> static> void> main(String args[])> >{> >Stack stack =>new> Stack();> >stack.push(>'Geeks'>);> >stack.push(>'For'>);> >stack.push(>'Geeks'>);> >stack.push(>'Geeks'>);> >// Iterator for the stack> >Iterator itr = stack.iterator();> >// Printing the stack> >while> (itr.hasNext()) {> >System.out.print(itr.next() +>' '>);> >}> >System.out.println();> >stack.pop();> >// Iterator for the stack> >itr = stack.iterator();> >// Printing the stack> >while> (itr.hasNext()) {> >System.out.print(itr.next() +>' '>);> >}> >}> }>

>

>

Produksjon

Geeks For Geeks Geeks Geeks For Geeks>

Merk: Stack er en underklasse av Vector og en eldre klasse. Den er trådsikker som kan være overhead i et miljø der trådsikkerhet ikke er nødvendig. Et alternativ til Stack er å bruke ArrayDequeue som ikke er trådsikker og har raskere array-implementering.

4. Køgrensesnitt

Som navnet antyder, opprettholder et køgrensesnitt rekkefølgen FIFO (First In First Out) som ligner på en kølinje i den virkelige verden. Dette grensesnittet er dedikert til å lagre alle elementene der rekkefølgen på elementene betyr noe. For eksempel, når vi prøver å bestille en billett, selges billettene etter førstemann til mølla-prinsippet. Derfor får den personen hvis forespørsel kommer først inn i køen billetten. Det finnes ulike klasser som Prioritetskø , ArrayDeque , etc. Siden alle disse underklassene implementerer køen, kan vi instansiere et køobjekt med hvilken som helst av disse klassene.

For eksempel:

Queue pq = new PriorityQueue ();  Queue ad = new ArrayDeque ();  Where T is the type of the object.>

Den mest brukte implementeringen av køgrensesnittet er PriorityQueue.

Prioritetskø

En PriorityQueue brukes når objektene skal behandles basert på prioritet. Det er kjent at en kø følger First-In-First-Out-algoritmen, men noen ganger må elementene i køen behandles i henhold til prioritet, og denne klassen brukes i disse tilfellene. PriorityQueue er basert på prioritetshaugen. Elementene i prioritetskøen er ordnet i henhold til den naturlige rekkefølgen, eller etter en Komparator gitt ved byggetid i kø, avhengig av hvilken konstruktør som benyttes.

La oss forstå prioritetskøen med et eksempel:

Java




// Java program to demonstrate the working of> // priority queue in Java> import> java.util.*;> class> GfG {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating empty priority queue> >PriorityQueue pQueue> >=>new> PriorityQueue();> >// Adding items to the pQueue using add()> >pQueue.add(>10>);> >pQueue.add(>20>);> >pQueue.add(>15>);> >// Printing the top element of PriorityQueue> >System.out.println(pQueue.peek());> >// Printing the top element and removing it> >// from the PriorityQueue container> >System.out.println(pQueue.poll());> >// Printing the top element again> >System.out.println(pQueue.peek());> >}> }>

>

>

Produksjon

10 10 15>

5. Og grensesnittet

Dette er en veldig liten variasjon av For eksempel:

Deque ad = new ArrayDeque ();  Where T is the type of the object.>

Klassen som implementerer deque-grensesnittet er ArrayDeque.

ArrayDeque

ArrayDeque-klassen som er implementert i samlingsrammeverket gir oss en måte å bruke array som kan endres størrelse. Dette er en spesiell type array som vokser og lar brukere legge til eller fjerne et element fra begge sider av køen. Array-deques har ingen kapasitetsbegrensninger, og de vokser etter behov for å støtte bruken.

La oss forstå ArrayDeque med et eksempel:

Java




// Java program to demonstrate the> // ArrayDeque class in Java> import> java.util.*;> public> class> ArrayDequeDemo {> >public> static> void> main(String[] args)> >{> >// Initializing an deque> >ArrayDeque de_que> >=>new> ArrayDeque(>10>);> >// add() method to insert> >de_que.add(>10>);> >de_que.add(>20>);> >de_que.add(>30>);> >de_que.add(>40>);> >de_que.add(>50>);> >System.out.println(de_que);> >// clear() method> >de_que.clear();> >// addFirst() method to insert the> >// elements at the head> >de_que.addFirst(>564>);> >de_que.addFirst(>291>);> >// addLast() method to insert the> >// elements at the tail> >de_que.addLast(>24>);> >de_que.addLast(>14>);> >System.out.println(de_que);> >}> }>

>

>

Produksjon

[10, 20, 30, 40, 50] [291, 564, 24, 14]>

6. Angi grensesnitt

Et sett er en uordnet samling av objekter der dupliserte verdier ikke kan lagres. Denne samlingen brukes når vi ønsker å unngå duplisering av objektene og ønsker å lagre kun de unike objektene. Dette settgrensesnittet er implementert av forskjellige klasser som HashSet, TreeSet, LinkedHashSet, etc. Siden alle underklassene implementerer settet, kan vi instansiere et settobjekt med hvilken som helst av disse klassene.

For eksempel:

Set hs = new HashSet ();  Set lhs = new LinkedHashSet ();  Set ts = new TreeSet ();  Where T is the type of the object.>

Følgende er klassene som implementerer Set-grensesnittet:

Jeg). HashSet

HashSet-klassen er en iboende implementering av hashtabelldatastrukturen. Objektene som vi setter inn i HashSet garanterer ikke å bli satt inn i samme rekkefølge. Objektene settes inn basert på deres hashkode. Denne klassen tillater også innsetting av NULL-elementer. La oss forstå HashSet med et eksempel:

Java




// Java program to demonstrate the> // working of a HashSet> import> java.util.*;> public> class> HashSetDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating HashSet and> >// adding elements> >HashSet hs =>new> HashSet();> >hs.add(>'Geeks'>);> >hs.add(>'For'>);> >hs.add(>'Geeks'>);> >hs.add(>'Is'>);> >hs.add(>'Very helpful'>);> >// Traversing elements> >Iterator itr = hs.iterator();> >while> (itr.hasNext()) {> >System.out.println(itr.next());> >}> >}> }>

>

>

Produksjon

Very helpful Geeks For Is>

ii). LinkedHashSet

Et LinkedHashSet er veldig likt et HashSet. Forskjellen er at denne bruker en dobbeltlenket liste for å lagre dataene og beholder rekkefølgen av elementene.

La oss forstå LinkedHashSet med et eksempel:

Java




// Java program to demonstrate the> // working of a LinkedHashSet> import> java.util.*;> public> class> LinkedHashSetDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating LinkedHashSet and> >// adding elements> >LinkedHashSet lhs> >=>new> LinkedHashSet();> >lhs.add(>'Geeks'>);> >lhs.add(>'For'>);> >lhs.add(>'Geeks'>);> >lhs.add(>'Is'>);> >lhs.add(>'Very helpful'>);> >// Traversing elements> >Iterator itr = lhs.iterator();> >while> (itr.hasNext()) {> >System.out.println(itr.next());> >}> >}> }>

>

>

Produksjon

Geeks For Is Very helpful>

7. Sorted Set Interface

Dette grensesnittet er veldig likt det angitte grensesnittet. Den eneste forskjellen er at dette grensesnittet har ekstra metoder som opprettholder rekkefølgen av elementene. Det sorterte sett-grensesnittet utvider sett-grensesnittet og brukes til å håndtere dataene som må sorteres. Klassen som implementerer dette grensesnittet er TreeSet. Siden denne klassen implementerer SortedSet, kan vi instansiere et SortedSet-objekt med denne klassen.

For eksempel:

SortedSet ts = new TreeSet ();  Where T is the type of the object.>

Klassen som implementerer det sorterte sett-grensesnittet er TreeSet.

Tresett

TreeSet-klassen bruker et tre for lagring. Rekkefølgen av elementene opprettholdes av et sett som bruker deres naturlige rekkefølge uansett om en eksplisitt komparator er gitt eller ikke. Dette må samsvare med likes hvis det skal implementere Set-grensesnittet på riktig måte. Den kan også bestilles av en komparator som leveres på et fastsatt tidspunkt, avhengig av hvilken konstruktør som brukes.

La oss forstå TreeSet med et eksempel:

Java




// Java program to demonstrate the> // working of a TreeSet> import> java.util.*;> public> class> TreeSetDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating TreeSet and> >// adding elements> >TreeSet ts =>new> TreeSet();> >ts.add(>'Geeks'>);> >ts.add(>'For'>);> >ts.add(>'Geeks'>);> >ts.add(>'Is'>);> >ts.add(>'Very helpful'>);> >// Traversing elements> >Iterator itr = ts.iterator();> >while> (itr.hasNext()) {> >System.out.println(itr.next());> >}> >}> }>

>

>

Produksjon

For Geeks Is Very helpful>

8. Kartgrensesnitt

Et kart er en datastruktur som støtter nøkkelverdi-paret for kartlegging av dataene. Dette grensesnittet støtter ikke dupliserte nøkler fordi den samme nøkkelen ikke kan ha flere tilordninger, men det tillater dupliserte verdier i forskjellige nøkler. Et kart er nyttig hvis det er data og vi ønsker å utføre operasjoner på grunnlag av nøkkelen. Dette kartgrensesnittet er implementert av forskjellige klasser som HashMap , Trekart , osv. Siden alle underklassene implementerer kartet, kan vi instansiere et kartobjekt med hvilken som helst av disse klassene.

For eksempel:

Map hm = new HashMap ();  Map tm = new TreeMap ();   Where T is the type of the object.>

Den ofte brukte implementeringen av et kartgrensesnitt er et HashMap.

HashMap

HashMap gir den grunnleggende implementeringen av kartgrensesnittet til Java. Den lagrer dataene i (nøkkel, verdi) par. For å få tilgang til en verdi i et HashMap, må vi kjenne nøkkelen til den. HashMap bruker en teknikk kalt Hashing. Hashing er en teknikk for å konvertere en stor streng til en liten streng som representerer den samme strengen, slik at indekseringen og søkeoperasjonene går raskere. HashSet bruker også HashMap internt.

La oss forstå HashMap med et eksempel:

Java




// Java program to demonstrate the> // working of a HashMap> import> java.util.*;> public> class> HashMapDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating HashMap and> >// adding elements> >HashMap hm> >=>new> HashMap();> >hm.put(>1>,>'Geeks'>);> >hm.put(>2>,>'For'>);> >hm.put(>3>,>'Geeks'>);> >// Finding the value for a key> >System.out.println(>'Value for 1 is '> + hm.get(>1>));> >// Traversing through the HashMap> >for> (Map.Entry e : hm.entrySet())> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> }>

>

>

Produksjon

Value for 1 is Geeks 1 Geeks 2 For 3 Geeks>