Qualsevol grup d'objectes individuals que es representi com una unitat única es coneix com a col·lecció d'objectes Java. A Java, un marc separat anomenat Marc de la col·lecció s'ha definit al JDK 1.2 que conté totes les classes de col·lecció Java i la interfície.
A Java, la interfície Col·lecció ( java.util.Collection ) i la interfície del mapa ( java.util.Map ) són les dues interfícies arrel principals de les classes de col·lecció Java.
Què hauríeu d'aprendre a les col·leccions de Java?
- Interfície de llista
- Classe de llista abstracta
- Classe de llista seqüencial abstracta
- Llista de matrius
- Classe vectorial
- Classe de pila
- Classe LinkedList
- Interfície de cua
- Bloqueig de la interfície de la cua
- Classe AbstractQueue
- Classe PriorityQueue
- Classe PriorityBlockingQueue
- Classe ConcurrentLinkedQueue
- Classe ArrayBlockingQueue
- Classe DelayQueue
- Classe LinkedBlockingQueue
- LinkedTransferQueue
- I la interfície
- Interfície BlockingDeque
- Classe ConcurrentLinkedDeque
- Classe ArrayDeque
- Estableix la interfície
- Classe de conjunt abstracte
- Classe CopyOnWriteArraySet
- Classe EnumSet
- Classe ConcurrentHashMap
- Classe HashSet
- Classe LinkedHashSet
- Interfície SortedSet
- Interfície NavigableSet
- Conjunt d'arbres
- Classe ConcurrentSkipListSet
- Interfície de mapes
- Interfície SortedMap
- Interfície NavigableMap
- Interfície ConcurrentMap
- Classe TreeMap
- Classe AbstractMap
- Classe ConcurrentHashMap
- Classe EnumMap
- Classe HashMap
- Classe IdentityHashMap
- Classe LinkedHashMap
- Classe HashTable
- Classe de propietats
- Altres conceptes importants
- Com convertir HashMap a ArrayList
- Seleccioneu aleatòriament elements d'una llista
- Com afegir tots els elements d'una col·lecció a una ArrayList
- Conversió de mapes de Java a llista
- Conversió Array a ArrayList
- Conversió ArrayList a Array
- Diferències entre Array i ArrayList
Què és un Framework a Java?
Un framework és un conjunt de classes i interfícies que proporcionen una arquitectura ja feta. Per implementar una nova característica o una classe, no cal definir un marc. Tanmateix, un disseny òptim orientat a objectes sempre inclou un marc amb una col·lecció de classes de manera que totes les classes realitzen el mateix tipus de tasca.
Necessitat d'un marc de col·lecció separada a Java
Abans d'introduir el Collection Framework (o abans de JDK 1.2), els mètodes estàndard per agrupar objectes (o col·leccions) Java eren Arrays o Vectors , o Taules hash . Totes aquestes col·leccions no tenien una interfície comuna. Per tant, tot i que l'objectiu principal de totes les col·leccions és el mateix, la implementació de totes aquestes col·leccions es va definir de manera independent i no tenia correlació entre elles. A més, és molt difícil que els usuaris recordin tots els diferents mètodes , sintaxi i constructors present a cada classe de col·lecció.
Entenem-ho amb un exemple d'afegir un element a una taula hash i un vector.
producte de punts numpy
Exemple:
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()> > }> }> |
>
>Sortida
1 1 geeks>
Com podem observar, cap d'aquestes col·leccions (Array, Vector o Hashtable) implementa una interfície d'accés de membres estàndard, era molt difícil per als programadors escriure algorismes que puguin funcionar per a tot tipus de col·leccions. Un altre inconvenient és que la majoria dels mètodes 'Vector' són finals, el que significa que no podem ampliar la classe 'Vector' per implementar un tipus similar de Col·lecció. Per tant, els desenvolupadors de Java van decidir crear una interfície comuna per fer front als problemes esmentats anteriorment i van introduir el marc de col·lecció a la publicació del JDK 1.2, que tant els vectors heretats com les taules hash es van modificar per adaptar-se al marc de col·lecció.
Avantatges del Java Collection Framework
Com que la manca d'un marc de recollida va donar lloc al conjunt d'inconvenients anteriors, els següents són els avantatges del marc de recollida.
- API coherent: L'API té un conjunt bàsic d'interfícies com Col · lecció , Conjunt , Llista , o Mapa , totes les classes (ArrayList, LinkedList, Vector, etc.) que implementen aquestes interfícies tenen alguns conjunt de mètodes comuns.
- Redueix l'esforç de programació: Un programador no s'ha de preocupar pel disseny de la col·lecció, sinó que pot centrar-se en el millor ús del seu programa. Per tant, el concepte bàsic de programació orientada a objectes (és a dir, abstracció) s'ha implementat amb èxit.
- Augmenta la velocitat i la qualitat del programa: Augmenta el rendiment proporcionant implementacions d'alt rendiment d'estructures i algorismes de dades útils perquè, en aquest cas, el programador no necessita pensar en la millor implementació d'una estructura de dades específica. Simplement pot utilitzar la millor implementació per augmentar dràsticament el rendiment del seu algorisme/programa.
Jerarquia del marc de col·lecció a Java
El paquet d'utilitat (java.util) conté totes les classes i interfícies que requereix el marc de col·lecció. El marc de la col·lecció conté una interfície anomenada interfície iterable que proporciona a l'iterador per iterar totes les col·leccions. Aquesta interfície s'amplia amb la interfície de col·lecció principal que actua com a arrel per al marc de col·lecció. Totes les col·leccions amplien aquesta interfície de col·lecció, ampliant així les propietats de l'iterador i els mètodes d'aquesta interfície. La figura següent il·lustra la jerarquia del marc de col·lecció.
Abans d'entendre els diferents components del marc anterior, primer entenem una classe i una interfície.
- Classe : Una classe és un pla o prototip definit per l'usuari a partir del qual es creen objectes. Representa el conjunt de propietats o mètodes que són comuns a tots els objectes d'un mateix tipus.
- Interfície : Com una classe, una interfície pot tenir mètodes i variables, però els mètodes declarats en una interfície són abstractes per defecte (només signatura del mètode, ningú). Les interfícies especifiquen què ha de fer una classe i no com. És el pla de la classe.
Mètodes de la interfície de col·lecció
Aquesta interfície conté diversos mètodes que poden ser utilitzats directament per totes les col·leccions que implementen aquesta interfície. Ells són:
Mètode | Descripció |
---|---|
afegir (objecte) | Aquest mètode s'utilitza per afegir un objecte a la col·lecció. |
addAll(Col·lecció c) | Aquest mètode afegeix tots els elements de la col·lecció donada a aquesta col·lecció. |
clar () | Aquest mètode elimina tots els elements d'aquesta col·lecció. |
conté (Objecte o) | Aquest mètode retorna true si la col·lecció conté l'element especificat. |
contéAll(Col·lecció c) | Aquest mètode retorna true si la col·lecció conté tots els elements de la col·lecció donada. |
és igual a (Objecte o) | Aquest mètode compara l'objecte especificat amb aquesta col·lecció per a la igualtat. |
hashCode() | Aquest mètode s'utilitza per retornar el valor del codi hash per a aquesta col·lecció. |
està buit() | Aquest mètode retorna true si aquesta col·lecció no conté cap element. |
iterador() | Aquest mètode retorna un iterador sobre els elements d'aquesta col·lecció. |
màxim () | Aquest mètode s'utilitza per retornar el valor màxim present a la col·lecció. |
parallelStream() | Aquest mètode retorna un Stream paral·lel amb aquesta col·lecció com a font. |
eliminar (Objecte o) | Aquest mètode s'utilitza per eliminar l'objecte donat de la col·lecció. Si hi ha valors duplicats, aquest mètode elimina la primera ocurrència de l'objecte. |
removeAll(Col·lecció c) | Aquest mètode s'utilitza per eliminar tots els objectes esmentats a la col·lecció donada de la col·lecció. |
removeIf (filtre de predicats) | Aquest mètode s'utilitza per eliminar tots els elements d'aquesta col·lecció que compleixen el donat predicat . |
retainAll(Col·lecció c) | Aquest mètode s'utilitza per retenir només els elements d'aquesta col·lecció que estan continguts a la col·lecció especificada. |
mida () | Aquest mètode s'utilitza per retornar el nombre d'elements de la col·lecció. |
divisor () | Aquest mètode s'utilitza per crear un Divisor sobre els elements d'aquesta col·lecció. |
corrent() | Aquest mètode s'utilitza per retornar un flux seqüencial amb aquesta col·lecció com a font. |
toArray() | Aquest mètode s'utilitza per retornar una matriu que conté tots els elements d'aquesta col·lecció. |
Interfícies que amplien la interfície de col·leccions de Java
El marc de recollida conté múltiples interfícies on cada interfície s'utilitza per emmagatzemar un tipus específic de dades. A continuació es mostren les interfícies presents al framework.
1. Interfície iterable
Aquesta és la interfície arrel per a tot el marc de col·lecció. La interfície de col·lecció amplia la interfície iterable. Per tant, de manera inherent, totes les interfícies i classes implementen aquesta interfície. La funcionalitat principal d'aquesta interfície és proporcionar un iterador per a les col·leccions. Per tant, aquesta interfície només conté un mètode abstracte que és l'iterador. Torna el
Iterator iterator();>
2. Interfície de col·lecció
Aquesta interfície amplia la interfície iterable i és implementada per totes les classes del marc de col·lecció. Aquesta interfície conté tots els mètodes bàsics que té cada col·lecció, com afegir les dades a la col·lecció, eliminar les dades, esborrar les dades, etc. Tots aquests mètodes s'implementen en aquesta interfície perquè aquests mètodes són implementats per totes les classes independentment del seu estil. d'implementació. A més, tenir aquests mètodes en aquesta interfície garanteix que els noms dels mètodes siguin universals per a totes les col·leccions. Per tant, en resum, podem dir que aquesta interfície construeix una base sobre la qual s'implementen les classes de col·lecció.
3. Interfície de llista
Aquesta és una interfície secundària de la interfície de col·lecció. Aquesta interfície està dedicada a les dades del tipus llista en la qual podem emmagatzemar totes les col·leccions ordenades dels objectes. Això també permet que hi hagi dades duplicades. Aquesta interfície de llista està implementada per diverses classes com ArrayList, Vector, Stack, etc. Com que totes les subclasses implementen la llista, podem crear una instancia d'un objecte llista amb qualsevol d'aquestes classes.
Per exemple:
List al = new ArrayList (); List ll = new LinkedList (); List v = new Vector (); Where T is the type of the object>
Les classes que implementen la interfície List són les següents:
i). ArrayList
ArrayList ens proporciona matrius dinàmiques en Java. Tanmateix, pot ser més lent que les matrius estàndard, però pot ser útil en programes on es necessita molta manipulació a la matriu. La mida d'una ArrayList augmenta automàticament si la col·lecció creix o es redueix si s'eliminen els objectes de la col·lecció. Java ArrayList ens permet accedir a la llista aleatòriament. ArrayList no es pot utilitzar per classe d'embolcall per aquests casos.
Entenem la ArrayList amb l'exemple següent:
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) + ' '); } }> |
>
>Sortida
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
ii). LinkedList
La classe LinkedList és una implementació de l' Entenem la LinkedList amb l'exemple següent:
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) + ' '); } }> |
>
>Sortida
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
iii). Vector
Un vector ens proporciona matrius dinàmiques en Java. Tanmateix, pot ser més lent que les matrius estàndard, però pot ser útil en programes on es necessita molta manipulació a la matriu. Això és idèntic a ArrayList pel que fa a la implementació. Tanmateix, la diferència principal entre un vector i una ArrayList és que un Vector està sincronitzat i una ArrayList no està sincronitzada.
Entenem el Vector amb un exemple:
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) + ' '); } }> |
>
>Sortida
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
iv). Pila
Apila models de classe i implementa elúltim en entrar primer en sortir. A més de les operacions bàsiques push i pop, la classe ofereix tres funcions més buit, cerca i mira. La classe també es pot anomenar la subclasse de Vector.
Entenem la pila amb un exemple:
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() +> ' '> );> > }> > }> }> |
>
>Sortida
Geeks For Geeks Geeks Geeks For Geeks>
Nota: Stack és una subclasse de Vector i una classe heretada. És segur per a fils, cosa que pot ser sobre la sobrecàrrega en un entorn on no es necessita seguretat per a fils. Una alternativa a Stack és utilitzar ArrayDequeue que no és segur per a fils i té una implementació de matriu més ràpida.
4. Interfície de cua
Com el seu nom indica, una interfície de cua manté l'ordre FIFO (First In First Out) similar a una línia de cua del món real. Aquesta interfície està dedicada a emmagatzemar tots els elements on l'ordre dels elements importa. Per exemple, sempre que intentem reservar una entrada, les entrades es venen per ordre d'arribada. Per tant, la persona la sol·licitud de la qual arriba primer a la cua rep el bitllet. Hi ha diferents classes com PriorityQueue , ArrayDeque , etc. Com que totes aquestes subclasses implementen la cua, podem crear una instancia d'un objecte de cua amb qualsevol d'aquestes classes.
Per exemple:
Queue pq = new PriorityQueue (); Queue ad = new ArrayDeque (); Where T is the type of the object.>
La implementació més utilitzada de la interfície de la cua és PriorityQueue.
Cua de prioritats
S'utilitza una PriorityQueue quan se suposa que els objectes s'han de processar en funció de la prioritat. Se sap que una cua segueix l'algorisme First-In-First-Out, però de vegades cal que els elements de la cua es processin segons la prioritat i aquesta classe s'utilitza en aquests casos. PriorityQueue es basa en l'munt de prioritat. Els elements de la cua de prioritats s'ordenen segons l'ordenació natural, o per a Comparador proporcionat en el moment de la construcció de la cua, depenent del constructor que s'utilitzi.
Entenem la cua de prioritats amb un exemple:
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());> > }> }> |
>
>Sortida
10 10 15>
5. I la interfície
Aquesta és una variació molt lleugera de la Per exemple:
Deque ad = new ArrayDeque (); Where T is the type of the object.>
La classe que implementa la interfície deque és ArrayDeque.
ArrayDeque
La classe ArrayDeque que s'implementa al marc de la col·lecció ens proporciona una manera d'aplicar una matriu redimensionable. Aquest és un tipus especial de matriu que creix i permet als usuaris afegir o eliminar un element d'ambdós costats de la cua. Els deques de matriu no tenen restriccions de capacitat i creixen segons sigui necessari per suportar l'ús.
Entenem ArrayDeque amb un exemple:
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);> > }> }> |
>
>Sortida
[10, 20, 30, 40, 50] [291, 564, 24, 14]>
6. Estableix la interfície
Un conjunt és una col·lecció no ordenada d'objectes en què no es poden emmagatzemar valors duplicats. Aquesta col·lecció s'utilitza quan volem evitar la duplicació dels objectes i volem emmagatzemar només els objectes únics. Aquesta interfície de conjunt és implementada per diverses classes com HashSet, TreeSet, LinkedHashSet, etc. Com que totes les subclasses implementen el conjunt, podem crear una instancia d'un objecte conjunt amb qualsevol d'aquestes classes.
Per exemple:
Set hs = new HashSet (); Set lhs = new LinkedHashSet (); Set ts = new TreeSet (); Where T is the type of the object.>
Les següents són les classes que implementen la interfície Set:
i). HashSet
La classe HashSet és una implementació inherent de l'estructura de dades de la taula hash. Els objectes que inserim al HashSet no garanteixen que s'insereixin en el mateix ordre. Els objectes s'insereixen en funció del seu codi hash. Aquesta classe també permet la inserció d'elements NULL. Entenem HashSet amb un exemple:
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());> > }> > }> }> |
>
>Sortida
Very helpful Geeks For Is>
ii). LinkedHashSet
Un LinkedHashSet és molt semblant a un HashSet. La diferència és que aquesta utilitza una llista doblement enllaçada per emmagatzemar les dades i conserva l'ordenació dels elements.
Entenem el LinkedHashSet amb un exemple:
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());> > }> > }> }> |
>
>Sortida
Geeks For Is Very helpful>
7. Interfície de conjunt ordenada
Aquesta interfície és molt semblant a la interfície establerta. L'única diferència és que aquesta interfície té mètodes addicionals que mantenen l'ordenació dels elements. La interfície del conjunt ordenat amplia la interfície del conjunt i s'utilitza per gestionar les dades que cal ordenar. La classe que implementa aquesta interfície és TreeSet. Com que aquesta classe implementa el SortedSet, podem crear una instancia d'un objecte SortedSet amb aquesta classe.
Per exemple:
SortedSet ts = new TreeSet (); Where T is the type of the object.>
La classe que implementa la interfície de conjunt ordenat és TreeSet.
Conjunt d'arbres
La classe TreeSet utilitza un arbre per a l'emmagatzematge. L'ordenació dels elements es manté mitjançant un conjunt utilitzant el seu ordenament natural tant si es proporciona un comparador explícit com si no. Això ha de ser coherent amb els iguals si es vol implementar correctament la interfície Set. També es pot ordenar mitjançant un comparador proporcionat en un moment de creació establert, depenent del constructor que s'utilitzi.
Entenem TreeSet amb un exemple:
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());> > }> > }> }> |
>
>Sortida
For Geeks Is Very helpful>
8. Interfície de mapes
Un mapa és una estructura de dades que admet el parell clau-valor per mapejar les dades. Aquesta interfície no admet claus duplicades perquè la mateixa clau no pot tenir múltiples mapes, però, permet valors duplicats en claus diferents. Un mapa és útil si hi ha dades i volem fer operacions a partir de la clau. Aquesta interfície de mapa està implementada per diverses classes com HashMap , TreeMap , etc. Com que totes les subclasses implementen el mapa, podem crear una instancia d'un objecte mapa amb qualsevol d'aquestes classes.
Per exemple:
Map hm = new HashMap (); Map tm = new TreeMap (); Where T is the type of the object.>
La implementació que s'utilitza amb freqüència d'una interfície de mapa és un HashMap.
HashMap
HashMap proporciona la implementació bàsica de la interfície Map de Java. Emmagatzema les dades en parells (clau, valor). Per accedir a un valor en un HashMap, hem de conèixer la seva clau. HashMap utilitza una tècnica anomenada Hashing. El hashing és una tècnica per convertir una cadena gran en una cadena petita que representa la mateixa cadena perquè les operacions d'indexació i cerca siguin més ràpides. HashSet també utilitza HashMap internament.
Entenem el HashMap amb un exemple:
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());> > }> }> |
>
>Sortida
Value for 1 is Geeks 1 Geeks 2 For 3 Geeks>