Orice grup de obiecte individuale care sunt reprezentate ca o singură unitate este cunoscut ca o colecție Java de obiecte. În Java, un cadru separat numit Cadrul de colectare a fost definit în JDK 1.2, care conține toate clasele și interfața Java Collection.
În Java, interfața Collection ( java.util.Colection ) și interfața Hartă ( java.util.Map ) sunt cele două interfețe rădăcină principale ale claselor de colecție Java.
Ce ar trebui să înveți în colecțiile Java?
- Interfață Listă
- Clasa Lista Abstracte
- Clasa de listă secvențială abstractă
- Lista de matrice
- Clasa Vector
- Clasa Stiva
- Clasa LinkedList
- Interfață coadă
- Blocarea interfeței coadă
- Clasa AbstractQueue
- Clasa PriorityQueue
- Clasa PriorityBlockingQueue
- Clasa ConcurrentLinkedQueue
- Clasa ArrayBlockingQueue
- Clasa DelayQueue
- Clasa LinkedBlockingQueue
- LinkedTransferQueue
- Și interfața
- Interfața BlockingDeque
- Clasa ConcurrentLinkedDeque
- Clasa ArrayDeque
- Setați interfața
- Clasa set abstract
- Clasa CopyOnWriteArraySet
- Clasa EnumSet
- Clasa ConcurrentHashMap
- Clasa HashSet
- Clasa LinkedHashSet
- Interfață SortedSet
- Interfață NavigableSet
- TreeSet
- Clasa ConcurrentSkipListSet
- Interfață de hartă
- Interfață SortedMap
- Interfață NavigableMap
- Interfață ConcurrentMap
- Clasa TreeMap
- Clasa AbstractMap
- Clasa ConcurrentHashMap
- Clasa EnumMap
- Clasa HashMap
- Clasa IdentityHashMap
- Clasa LinkedHashMap
- Clasa HashTable
- Clasa proprietati
- Alte concepte importante
- Cum se transformă HashMap în ArrayList
- Selectați aleatoriu articole dintr-o listă
- Cum să adăugați toate elementele dintr-o colecție la o ArrayList
- Conversia hărților Java în listă
- Conversie Array în ArrayList
- Conversie ArrayList în Array
- Diferențele dintre Array și ArrayList
Ce este un cadru în Java?
Un cadru este un set de clase și interfețe care oferă o arhitectură gata făcută. Pentru a implementa o nouă caracteristică sau o clasă, nu este nevoie să definiți un cadru. Cu toate acestea, un design optim orientat pe obiect include întotdeauna un cadru cu o colecție de clase, astfel încât toate clasele îndeplinesc același tip de sarcină.
Nevoia unui cadru de colecție separată în Java
Înainte de introducerea cadrului de colectare (sau înainte de JDK 1.2), metodele standard de grupare a obiectelor (sau colecțiilor) Java erau Matrice sau Vectori , sau Hashtables . Toate aceste colecții nu aveau o interfață comună. Prin urmare, deși scopul principal al tuturor colecțiilor este același, implementarea tuturor acestor colecții a fost definită independent și nu a avut nicio corelație între ele. Și, de asemenea, este foarte dificil pentru utilizatori să-și amintească toate diferitele metode , sintaxă și constructorii prezent în fiecare clasă de colecție.
Să înțelegem acest lucru cu un exemplu de adăugare a unui element într-o tabelă hash și a unui vector.
string tokenizer java
Exemplu:
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()> >}> }> |
>
>Ieșire
1 1 geeks>
După cum putem observa, niciuna dintre aceste colecții (Array, Vector sau Hashtable) nu implementează o interfață standard de acces pentru membri, a fost foarte dificil pentru programatori să scrie algoritmi care pot funcționa pentru toate tipurile de colecții. Un alt dezavantaj este că majoritatea metodelor „Vector” sunt finale, ceea ce înseamnă că nu putem extinde clasa „Vector” pentru a implementa un tip similar de Colecție. Prin urmare, dezvoltatorii Java au decis să vină cu o interfață comună pentru a face față problemelor menționate mai sus și au introdus Cadrul de colecție în postarea JDK 1.2, care atât vectorii moșteniți, cât și tabelele Hashtable au fost modificate pentru a se conforma cadrului de colecție.
Avantajele Java Collection Framework
Deoarece lipsa unui cadru de colectare a dat naștere la setul de dezavantaje de mai sus, următoarele sunt avantajele cadrului de colectare.
- API consistent: API-ul are un set de bază de interfețe precum Colectie , A stabilit , Listă , sau Hartă , au toate clasele (ArrayList, LinkedList, Vector etc.) care implementează aceste interfețe niste set comun de metode.
- Reduce efortul de programare: Un programator nu trebuie să-și facă griji cu privire la designul colecției, ci mai degrabă se poate concentra pe cea mai bună utilizare a acesteia în programul său. Prin urmare, conceptul de bază de programare orientată pe obiecte (adică abstracție) a fost implementat cu succes.
- Mărește viteza și calitatea programului: Mărește performanța prin furnizarea de implementări de înaltă performanță ale structurilor și algoritmilor de date utili, deoarece în acest caz, programatorul nu trebuie să se gândească la cea mai bună implementare a unei structuri de date specifice. El poate folosi pur și simplu cea mai bună implementare pentru a crește drastic performanța algoritmului/programului său.
Ierarhia cadrului de colectare în Java
Pachetul de utilitate, (java.util) conține toate clasele și interfețele care sunt cerute de cadrul de colecție. Cadrul de colecție conține o interfață numită interfață iterabilă care oferă iteratorului să itereze prin toate colecțiile. Această interfață este extinsă de interfața principală de colecție care acționează ca rădăcină pentru cadrul de colecție. Toate colecțiile extind această interfață de colecție extinzând astfel proprietățile iteratorului și metodele acestei interfețe. Figura următoare ilustrează ierarhia cadrului de colectare.
Înainte de a înțelege diferitele componente din cadrul de mai sus, să înțelegem mai întâi o clasă și o interfață.
- Clasă : O clasă este un model sau un prototip definit de utilizator din care sunt create obiecte. Reprezintă setul de proprietăți sau metode care sunt comune tuturor obiectelor de un singur tip.
- Interfață : Ca o clasă, o interfață poate avea metode și variabile, dar metodele declarate într-o interfață sunt implicit abstracte (doar semnătura metodei, nimeni). Interfețele specifică ce trebuie să facă o clasă și nu cum. Este planul clasei.
Metode ale interfeței de colectare
Această interfață conține diverse metode care pot fi utilizate direct de toate colecțiile care implementează această interfață. Sunt:
| Metodă | Descriere |
|---|---|
| adauga (obiect) | Această metodă este folosită pentru a adăuga un obiect la colecție. |
| addAll(Colecția c) | Această metodă adaugă toate elementele din colecția dată la această colecție. |
| clar() | Această metodă elimină toate elementele din această colecție. |
| conține (obiectul o) | Această metodă returnează true dacă colecția conține elementul specificat. |
| conţineAll(Colecţia c) | Această metodă returnează true dacă colecția conține toate elementele din colecția dată. |
| este egal(obiect o) | Această metodă compară obiectul specificat cu această colecție pentru egalitate. |
| hashCode() | Această metodă este folosită pentru a returna valoarea codului hash pentru această colecție. |
| este gol() | Această metodă returnează true dacă această colecție nu conține niciun element. |
| iterator() | Această metodă returnează un iterator peste elementele din această colecție. |
| max() | Această metodă este folosită pentru a returna valoarea maximă prezentă în colecție. |
| parallelStream() | Această metodă returnează un flux paralel cu această colecție ca sursă. |
| elimina (obiectul o) | Această metodă este folosită pentru a elimina obiectul dat din colecție. Dacă există valori duplicate, atunci această metodă elimină prima apariție a obiectului. |
| removeAll(Colecția c) | Această metodă este folosită pentru a elimina toate obiectele menționate în colecția dată din colecție. |
| removeIf(filtru predicat) | Această metodă este folosită pentru a elimina toate elementele acestei colecții care satisfac cele date predicat . |
| retainAll(Colecția c) | Această metodă este utilizată pentru a reține numai elementele din această colecție care sunt conținute în colecția specificată. |
| mărimea() | Această metodă este folosită pentru a returna numărul de elemente din colecție. |
| spliterator() | Această metodă este folosită pentru a crea un Spliterator peste elementele din această colecție. |
| curent() | Această metodă este folosită pentru a returna un flux secvenţial cu această colecţie ca sursă. |
| toArray() | Această metodă este folosită pentru a returna o matrice care conține toate elementele din această colecție. |
Interfețe care extind interfața Java Collections
Cadrul de colectare conține mai multe interfețe în care fiecare interfață este utilizată pentru a stoca un anumit tip de date. Următoarele sunt interfețele prezente în cadru.
1. Interfață iterabilă
Aceasta este interfața rădăcină pentru întregul cadru de colecție. Interfața de colecție extinde interfața iterabilă. Prin urmare, în mod inerent, toate interfețele și clasele implementează această interfață. Funcționalitatea principală a acestei interfețe este de a oferi un iterator pentru colecții. Prin urmare, această interfață conține o singură metodă abstractă care este iteratorul. Acesta returnează
Iterator iterator();>
2. Interfață de colecție
Această interfață extinde interfața iterabilă și este implementată de toate clasele din cadrul de colecție. Această interfață conține toate metodele de bază pe care le are fiecare colecție, cum ar fi adăugarea datelor în colecție, eliminarea datelor, ștergerea datelor etc. Toate aceste metode sunt implementate în această interfață deoarece aceste metode sunt implementate de toate clasele, indiferent de stilul lor. de implementare. Și, de asemenea, având aceste metode în această interfață se asigură că numele metodelor sunt universale pentru toate colecțiile. Prin urmare, pe scurt, putem spune că această interfață construiește o bază pe care sunt implementate clasele de colecție.
3. Interfață Listă
Aceasta este o interfață copil a interfeței de colecție. Această interfață este dedicată datelor de tip listă în care putem stoca toate colecțiile ordonate ale obiectelor. Acest lucru permite, de asemenea, să fie prezente date duplicate în el. Această interfață listă este implementată de diferite clase precum ArrayList, Vector, Stack, etc. Deoarece toate subclasele implementează lista, putem instanția un obiect listă cu oricare dintre aceste clase.
De exemplu:
List al = new ArrayList (); List ll = new LinkedList (); List v = new Vector (); Where T is the type of the object>
Clasele care implementează interfața Listă sunt următoarele:
i). ArrayList
ArrayList ne oferă matrice dinamice în Java. Cu toate acestea, poate fi mai lent decât matricele standard, dar poate fi util în programele în care este nevoie de multă manipulare în matrice. Mărimea unui ArrayList crește automat dacă colecția crește sau se micșorează dacă obiectele sunt eliminate din colecție. Java ArrayList ne permite să accesăm aleatoriu lista. ArrayList nu poate fi folosit pentru clasa de ambalare pentru astfel de cazuri.
Să înțelegem ArrayList cu următorul exemplu:
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) + ' '); } }> |
>
>Ieșire
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
ii). LinkedList
Clasa LinkedList este o implementare a Să înțelegem LinkedList cu următorul exemplu:
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) + ' '); } }> |
>
>Ieșire
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
iii). Vector
Un vector ne oferă matrice dinamice în Java. Cu toate acestea, poate fi mai lent decât matricele standard, dar poate fi util în programele în care este nevoie de multă manipulare în matrice. Acesta este identic cu ArrayList în ceea ce privește implementarea. Totuși, diferența principală dintre un vector și un ArrayList este că un Vector este sincronizat și o ArrayList este nesincronizată.
Să înțelegem Vectorul cu un exemplu:
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) + ' '); } }> |
>
>Ieșire
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
iv). Grămadă
Stivuiți modele de clasă și implementeazăultimul-intrat-primul-ieșit. În plus față de operațiunile de bază push și pop, clasa oferă încă trei funcții gol, căutare și peek. Clasa poate fi denumită și subclasa Vector.
Să înțelegem stiva cu un exemplu:
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() +>' '>);> >}> >}> }> |
>
>Ieșire
Geeks For Geeks Geeks Geeks For Geeks>
Notă: Stack este o subclasă a Vector și o clasă moștenită. Este sigur pentru fire, ceea ce poate fi deasupra capului într-un mediu în care siguranța firului nu este necesară. O alternativă la Stack este utilizarea ArrayDequeue care nu este thread-safe și are o implementare mai rapidă a matricei.
4. Interfață coadă
După cum sugerează și numele, o interfață de coadă menține ordinea FIFO (primul intrat, primul ieşit) similară cu o linie de coadă din lumea reală. Această interfață este dedicată stocării tuturor elementelor în care ordinea elementelor contează. De exemplu, ori de câte ori încercăm să rezervăm un bilet, biletele sunt vândute pe principiul primul venit, primul servit. Prin urmare, persoana a cărei cerere ajunge prima în coadă primește biletul. Sunt diverse clase de genul PriorityQueue , ArrayDeque , etc. Deoarece toate aceste subclase implementează coada, putem instanția un obiect coadă cu oricare dintre aceste clase.
De exemplu:
Queue pq = new PriorityQueue (); Queue ad = new ArrayDeque (); Where T is the type of the object.>
Implementarea cea mai frecvent utilizată a interfeței de coadă este PriorityQueue.
Coada prioritară
O PriorityQueue este folosită atunci când obiectele ar trebui să fie procesate pe baza priorității. Se știe că o coadă urmează algoritmul First-In-First-Out, dar uneori elementele cozii sunt necesare pentru a fi procesate în funcție de prioritate și această clasă este folosită în aceste cazuri. PriorityQueue se bazează pe heap-ul prioritar. Elementele cozii de prioritate sunt ordonate după ordonarea firească, sau după a Comparator furnizate la momentul construirii cozii, în funcție de constructorul utilizat.
Să înțelegem coada de prioritate cu un exemplu:
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());> >}> }> |
>
>Ieșire
10 10 15>
5. Și interfața
Aceasta este o foarte mică variație a De exemplu:
Deque ad = new ArrayDeque (); Where T is the type of the object.>
Clasa care implementează interfața deque este ArrayDeque.
ArrayDeque
Clasa ArrayDeque care este implementată în cadrul de colecție ne oferă o modalitate de a aplica o matrice redimensionabilă. Acesta este un tip special de matrice care crește și permite utilizatorilor să adauge sau să elimine un element de pe ambele părți ale cozii. Dec-urile de matrice nu au restricții de capacitate și cresc după cum este necesar pentru a sprijini utilizarea.
Să înțelegem ArrayDeque cu un exemplu:
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);> >}> }> |
>
>Ieșire
[10, 20, 30, 40, 50] [291, 564, 24, 14]>
6. Setați interfața
Un set este o colecție neordonată de obiecte în care nu pot fi stocate valori duplicate. Această colecție este folosită atunci când dorim să evităm duplicarea obiectelor și dorim să stocăm doar obiectele unice. Această interfață set este implementată de diferite clase precum HashSet, TreeSet, LinkedHashSet etc. Deoarece toate subclasele implementează setul, putem instanția un obiect set cu oricare dintre aceste clase.
De exemplu:
Set hs = new HashSet (); Set lhs = new LinkedHashSet (); Set ts = new TreeSet (); Where T is the type of the object.>
Următoarele sunt clasele care implementează interfața Set:
i). HashSet
Clasa HashSet este o implementare inerentă a structurii de date a tabelului hash. Obiectele pe care le introducem în HashSet nu garantează că vor fi inserate în aceeași ordine. Obiectele sunt inserate pe baza codului lor hash. Această clasă permite și inserarea elementelor NULL. Să înțelegem HashSet cu un exemplu:
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());> >}> >}> }> |
>
>Ieșire
Very helpful Geeks For Is>
ii). LinkedHashSet
Un LinkedHashSet este foarte asemănător cu un HashSet. Diferența este că aceasta utilizează o listă dublu legată pentru a stoca datele și păstrează ordinea elementelor.
Să înțelegem LinkedHashSet cu un exemplu:
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());> >}> >}> }> |
>
>Ieșire
Geeks For Is Very helpful>
7. Interfață set sortat
Această interfață este foarte asemănătoare cu interfața setată. Singura diferență este că această interfață are metode suplimentare care mențin ordonarea elementelor. Interfața setului sortat extinde interfața setului și este utilizată pentru a gestiona datele care trebuie sortate. Clasa care implementează această interfață este TreeSet. Deoarece această clasă implementează SortedSet, putem instanția un obiect SortedSet cu această clasă.
De exemplu:
SortedSet ts = new TreeSet (); Where T is the type of the object.>
Clasa care implementează interfața set sortat este TreeSet.
TreeSet
Clasa TreeSet folosește un Arbore pentru stocare. Ordinea elementelor este menținută de o mulțime folosind ordonarea lor naturală, indiferent dacă este furnizat sau nu un comparator explicit. Acest lucru trebuie să fie în concordanță cu equals dacă este pentru a implementa corect interfața Set. Poate fi comandat și de un Comparator furnizat la un moment stabilit de creare, în funcție de constructorul utilizat.
Să înțelegem TreeSet cu un exemplu:
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());> >}> >}> }> |
>
>Ieșire
For Geeks Is Very helpful>
8. Interfață de hartă
O hartă este o structură de date care acceptă perechea cheie-valoare pentru maparea datelor. Această interfață nu acceptă chei duplicate, deoarece aceeași cheie nu poate avea mai multe mapări, totuși, permite valori duplicate în chei diferite. O hartă este utilă dacă există date și dorim să facem operații pe baza cheii. Această interfață de hărți este implementată de diferite clase precum HashMap , Harta copacului , etc. Deoarece toate subclasele implementează harta, putem instanția un obiect hartă cu oricare dintre aceste clase.
De exemplu:
Map hm = new HashMap (); Map tm = new TreeMap (); Where T is the type of the object.>
Implementarea utilizată frecvent a unei interfețe Map este HashMap.
HashMap
HashMap oferă implementarea de bază a interfeței Map din Java. Stochează datele în perechi (Cheie, Valoare). Pentru a accesa o valoare dintr-un HashMap, trebuie să cunoaștem cheia acesteia. HashMap folosește o tehnică numită Hashing. Hashing este o tehnică de conversie a unui șir mare într-un șir mic care reprezintă același șir, astfel încât operațiunile de indexare și căutare să fie mai rapide. HashSet folosește și HashMap intern.
Să înțelegem HashMap cu un exemplu:
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());> >}> }> |
>
>Ieșire
Value for 1 is Geeks 1 Geeks 2 For 3 Geeks>