Tutorial sobre Java Collections Framework (JCF)

java collections framework tutorial

Proveu El Nostre Instrument Per Eliminar Problemes

Seleccioneu El Sistema Operatiu Trieu Un Programa De Projecció (Opcionalment)

Descriviu El Vostre Problema

Aquest tutorial explica Java Collections Framework (JCF) amb detalls juntament amb la jerarquia de col·leccions, diverses interfícies i els avantatges de JCF:

Espero que aquests tutorials eloqüents sobre això Sèrie Java per a principiants són realment útils per enriquir el vostre coneixement de Java.

El nostre tutorial anterior va informar més sobre el operacions bàsiques d'E / S a Java . En aquest tutorial coneixerem detalladament Java Collections Framework (JCF).

Java Collections Framework (JCF) conté interfícies, classes abstractes i classes que poden proporcionar l'arquitectura per emmagatzemar i manipular un grup d'objectes.

Java Collections Framework

Què aprendreu:

Tutorials de vídeo sobre Java Collections Framework

Coneixement de Arraylist a Java:

Estableix la interfície i la cua a Java amb exemples en temps real:

HashMap, TreeMap i HashTable a Java:

Fins ara hem vist variables que emmagatzemen diferents tipus de dades. Són unitats singulars i no són molt útils quan teniu grans quantitats de dades per emmagatzemar i tractar. Com sabem, les dades són el component més important del processament informàtic.

La vostra aplicació ha de ser capaç d’extreure i recopilar dades, processar-les per esbrinar informació útil i, també, passar-les d’un costat a l’altre perquè s’utilitzin de manera eficient per arribar a les solucions.

En aquest món del programari, emmagatzemem les dades que s’han d’estructurar d’una manera particular perquè els programes siguin capaços d’emmagatzemar, llegir, processar i finalment produir els resultats. Això es fa mitjançant estructures de dades.

Gairebé tots els llenguatges de programació admeten estructures de dades. L'estructura de dades es pot definir com una representació estructurada de dades. Els llenguatges de programació proporcionen funcions API (Application Programming Interface) per manipular les estructures de dades.

Framework de necessitat de col·lecció

Abans de Java 1.2, el llenguatge de programació Java suportava estructures de dades com ara matrius, vectors o taules de hash. Fer operacions en aquestes estructures de dades no va ser fàcil, ja que no hi havia cap interfície comuna que funcionés en aquestes estructures de dades.

Els programadors solien tenir dificultats per escriure algoritmes que funcionessin per a totes les estructures de dades i que suposessin un gran problema. Calia una interfície comuna que funcionés de manera coherent en totes les estructures de dades i que realitzés operacions de manera eficient.

Més tard, Java va crear un marc de col·leccions que és un grup de classes i interfícies que consisteix en diverses operacions que es poden realitzar en estructures de dades.

En aquest tutorial de Java Collections, parlarem del Java Collections Framework en general. Explorarem cadascun dels components de la col·lecció als nostres propers tutorials.

Java Collections Framework

Abans de definir un Java Collections Framework, coneixem el significat de la col·lecció i un framework.

Una col·lecció es pot definir com un grup d’objectes. Una col·lecció sol ser una sola unitat que consta de més d’un objecte. Un framework és un programari que té una interfície o arquitectura funcional ja feta i que també conté un conjunt de classes i interfícies que s’utilitzaran amb la interfície proporcionada.

Un marc de col·leccions es defineix com una arquitectura unificada i preparada que consisteix en el següent.

# 1) Algorismes

Es tracta de mètodes o conjunt d’enunciats que poden ajudar els programadors a buscar, ordenar i processar les dades recollides. La col·lecció ve empaquetada amb interfícies, classes i algorismes.

Les aplicacions que es desenvolupen heretant el marc de col·lecció tenen accés a aquests algoritmes i utilitzen els mètodes i procediments ja definits.

# 2) Interfícies

Les interfícies a Java proporcionen l’abstracció de la implementació, és a dir, mitjançant interfícies, l’usuari no és conscient dels detalls de la implementació, però només pot veure els mètodes i les dades necessaris per escriure una aplicació. La interfície de col·lecció té moltes interfícies que el programador pot implementar per escriure les seves pròpies classes.

# 3) Classes

Les classes de Framework Framework són estructures de dades que es poden implementar en un programa. Aquestes classes implementen la interfície 'Col·lecció' i, per tant, hereten tots els mètodes i definicions de la interfície de col·lecció.

Un marc de col·lecció s’utilitza per emmagatzemar i manipular la col·lecció que és el grup d’objectes.

El marc de col·lecció Java consisteix en algoritmes d’alt rendiment que realitzen operacions estàndard com la cerca, l’ordenació i el processament. Proporciona diverses implementacions estàndard, incloent LinkedList, TreeSet i HashSet per a les quals es proporcionen interfícies.

A continuació, entenem la jerarquia de la col·lecció Java.

Jerarquia de la col·lecció Java

Totes les classes i interfícies que es mostren a la jerarquia de la col·lecció Java següent pertanyen al paquet 'java.util. *'.

Jerarquia de la col·lecció Java

Com es mostra al diagrama anterior, la jerarquia de la col·lecció Java consta de diverses classes i interfícies. Com podeu veure, cadascuna de les classes hereta d'una interfície i totes les classes i interfícies, al seu torn, hereten d'una única interfície de 'col·lecció'.

Analitzem alguns mètodes habituals a la interfície de col·lecció juntament amb una breu introducció sobre cadascuna de les classes i interfícies que es mostren a la jerarquia anterior.

Interfície de col·lecció

La interfície de col·lecció és la interfície arrel. Totes les classes del marc de col·lecció implementen la interfície de col·lecció. Això significa que cada col·lecció tindrà els mètodes declarats a la interfície de la col·lecció.

A continuació es detallen alguns dels mètodes de la interfície de col·lecció.

no	Mètode prototip	Descripció
7	booleà predeterminat removeIf (filtre predicat)	Elimineu de la col·lecció tots els elements que satisfacin el predicat donat 'filtre'.
1	mida int públic ()	Retorna el nombre d'elements d'una col·lecció determinada.
2	public void clear ()	Esborra la col·lecció eliminant tots els elements de la col·lecció.
3	addició booleana pública (E e)	Insereix un element e a la col·lecció.
4	public booleanaddAll (Col·lecció c)	Inseriu tots els elements de la col·lecció donats per c a la col·lecció.
5	eliminació booleana pública (element Object)	Suprimiu l'element donat per 'element' de la col·lecció.
6	booleà públic removeAll (Collectionc)	Elimineu la col·lecció c de la col·lecció.
8	public booleanretainAll (Col·lecció c)	Suprimiu tots els elements de la col·lecció excepte els de la col·lecció especificada c.
9	iterador públic d'iteradors ()	Torna l'iterador de la col·lecció.
10	public Object () toArray ()	Convertiu la col·lecció en una matriu.
11	public T () toArray (T () a)	Convertiu la col·lecció en una matriu amb un tipus de retorn especificat.
12	booleà públic isEmpty ()	Torneu si la col·lecció està buida o no.
13	booleà públic conté (element Object)	Comproveu si una col·lecció conté l'element donat (operació de cerca).
14	public booleancontainsAll (Collectionc)	Comproveu si la col·lecció conté la col·lecció c especificada al seu interior.
15	predefinit Spliterator spliterator ()	Retorna el divisor sobre una col·lecció especificada.
16	booleanequals públics (element Object)	S’utilitza per fer coincidir dues col·leccions.
17	corrent per defecte parallelStream ()	Retorna el flux paral·lel utilitzant la col·lecció com a font.
18	Streamstream per defecte ()	Retorna un flux seqüencial utilitzant la col·lecció com a font.
19	public int hashCode ()	Retorna el codi hash numèric de la col·lecció.

Interfície iterable

La interfície Iterable també és la interfície base del marc de col·lecció. La interfície de col·lecció que és la interfície principal de totes les altres classes amplia la interfície Iterable. Per tant, totes les classes implementen una interfície de col·lecció així com una interfície Iterable.

La interfície Iterable només té un mètode iterador () que retorna l'iterador () que podeu utilitzar per iterar sobre els elements del tipus T.

Iterator iterator ()

Interfície iteradora

La interfície Iterator proporciona la possibilitat de recórrer els elements en una direcció cap endavant.

Els següents són els mètodes compatibles amb aquesta interfície.

no	Mètode prototip	Descripció
1	Public Object next ()	Primer retorna l'element i després mou el cursor per apuntar a l'element següent.
2	public booleà hasNext ()	Comprova si l'iterador té més elements.
3	buit públic remove ()	Elimina l'element que l'iterador retorna al final.

Interfície de llista

La interfície de llista hereta la interfície de col·lecció. La interfície de llista conté les estructures de dades que s’utilitzen per emmagatzemar dades ordenades o recopilar objectes. Aquestes estructures de dades són d’un tipus de llista. Aquestes estructures de dades que implementen la interfície de llista poden tenir o no valors duplicats.

La interfície de llista conté els mètodes que s’utilitzen per accedir, inserir o eliminar elements dels objectes de llista.

Les diverses classes que implementen la interfície de la llista són les següents:

Preguntes i respostes d'entrevistes de servidor sql durant 5 anys d'experiència

ArrayList
Llista enllaçada
Vector
Pila

Analitzarem breument cadascuna d’aquestes classes. Els nostres temes posteriors tindran un debat detallat sobre cadascuna de les classes del marc de col·lecció.

# 1) Llista de matrius

ArrayList és la implementació més senzilla de la interfície de la llista. ArrayList conserva l'ordre d'inserció i no està sincronitzat.

La definició general de l'estructura de dades ArrayList (Collection) és la següent:

List list1= new ArrayList ();

Un cop definida la llista, podeu utilitzar el mètode 'afegir' per afegir elements. Tingueu en compte que internament l'ArrayList utilitzava un mecanisme de matriu dinàmica.

Vegeu els exemples següents que creen una col·lecció de colors ArrayList.

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

Sortida:

ArrayList

El programa anterior mostra la demostració de la col·lecció ArrayList. Afegim valors de color a la col·lecció i després recorrem la col·lecció per mostrar valors individuals a la col·lecció mitjançant un iterador.

# 2) Llista enllaçada

La col·lecció LinkedList utilitza internament un mecanisme de llista doblement enllaçat per emmagatzemar elements. Pot contenir elements duplicats. Les operacions de recopilació de LinkedList són més ràpides, ja que no cal canviar els elements.

La definició general de crear una llista enllaçada és la següent:

List list2 = new LinkedList ();

El programa següent ho demostra la llista de noms de números enllaçats .

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

Sortida:

Llista enllaçada

Per tant, creem una llista enllaçada i després hi afegim elements mitjançant el mètode 'add'. A continuació, mitjançant un iterador, recorrem la llista enllaçada i mostrem cada element.

# 3) Vector

Vector és similar a ArrayList i utilitza una matriu dinàmica per emmagatzemar elements com ArrayList. Però el vector admet molts mètodes independents, a part de la col·lecció, que fa que sigui una millor opció per ser una col·lecció preferida.

La definició general de la col·lecció de vectors és:

List list3 = new Vector();

Tingueu en compte que, tot i que vector i ArrayList utilitzen el mateix mecanisme de matrius dinàmics, els elements vectorials estan sincronitzats.

El programa Java que es mostra a continuació mostra l’ús de vectors en el marc de col·lecció .

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

Sortida:

Vector

En aquest programa, hem definit una col·lecció de vectors formada per temes. Afegim diversos temes i després fem servir un iterador per generar els elements.

# 4) Pila

L’estructura de dades de la pila implementa la manera d’inserir elements de l’última entrada-primera sortida (LIFO). La pila és una subclasse del vector de classe (consulteu el diagrama de jerarquia de col·lecció anterior). A part dels seus propis mètodes, la col·lecció de pila també admet els mètodes de recollida de vectors.

La definició general de col·lecció Stack és:

List list4 = new Stack();

El programa següent implementa la col·lecció Stack .

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

Sortida:

Col·lecció de pila

Com podeu veure a la implementació anterior, els nous elements s'afegeixen a la pila mitjançant el fitxer 'Empènyer' operació. La pila té un únic punt d’entrada anomenat ‘Part superior de la pila’ i els elements s’enfonsen a la pila de la part superior. Així, l’últim element afegit es troba a la part superior de la pila.

Igual que afegir, els elements també s’eliminen d’un extrem, és a dir, la part superior de la pila. Per eliminar elements, s’utilitza una operació ‘pop’. Així, si crideu pop (), l'element de la part superior de la pila s'eliminarà.

A la sortida anterior, inserim l’element 2, 4, 6,8,10 i, a continuació, truquem a pop () perquè s’elimini 10.

Interfície de cua

Les col·leccions derivades de la interfície de cua segueixen l'ordre de primer en primer i primer de sortida (FIFO). Els elements s’insereixen en un extrem i s’eliminen de l’altre extrem. Per tant, l'element introduït primer passa a ser l'element que s'elimina primer.

A continuació es mostren les col·leccions que admeten la interfície de consulta.

PriorityQueue
i Interfície
ArrayDeque

Analitzem breument cadascun d’aquests.

# 1) PriorityQueue

A la col·lecció PriorityQueue, els elements emmagatzemats es processen en funció de les seves prioritats. No podeu emmagatzemar valors nuls a la cua de prioritat.

La definició general de la cua de prioritat és la següent:

Queue q1 = new PriorityQueue();

El programa següent implementa la cua de prioritat.

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

Sortida:

PriorityQueue

Una vegada més fem servir els colors com a elements de la cua de prioritat. Al programa anterior, hem utilitzat els mètodes add and remove per afegir elements a la cua i eliminar un element respectivament. Utilitzem el mètode peek () que retorna un element al qual apunta a la cua de prioritat.

Finalment mitjançant un iterador, es mostren els elements de la cua de prioritat.

# 2) interfície tàctil

Deque o una 'cua de doble extrem' és una estructura de dades que permet afegir i eliminar els elements dels dos extrems. La interfície deque del marc de col·lecció Java que amplia la interfície de cua.

Proporciona la funcionalitat de deque i té una classe que n'hereta un 'ArrayDeque'.

# 3) ArrayDeque

ArrayDeque implementa la interfície deque.

La definició general d'ArrayDeque és la següent:

Deque d = new ArrayDeque();

ArrayDeque us permet utilitzar la funcionalitat de Deque. A diferència d'altres col·leccions com ArrayList o stack, ArrayDeque no té restriccions en la seva capacitat.

L'exemple següent mostra la implementació d'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); } } }

Sortida:

ArrayDeque

Al programa anterior, definim una col·lecció ArrayDeque de tipus enter i hi afegim elements sencers mitjançant el mètode add. A continuació, es recorre la col·lecció mitjançant la construcció for.

Estableix la interfície

La interfície configurada forma part del paquet java.util i s’estén des de la interfície de col·lecció. El conjunt és una estructura que no permet que la col·lecció tingui valors duplicats i també més d’un valor nul.

Les següents classes implementen la interfície establerta.

HashSet
LinkedHashSet
Conjunt d'arbres

# 1) HashSet

La col·lecció HashSet que implementa la interfície Set té valors diferents emmagatzemats. Aquesta col·lecció utilitza la tècnica de hash per emmagatzemar els articles i utilitza la taula de hash per emmagatzemar elements.

T A continuació es mostra la definició general de la col·lecció HashSet.

Set s1 = new HashSet();

Hem implementat la implementació de HashSet al programa següent.

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

Sortida:

HashSet

Al programa anterior, creem una col·lecció de temes HashSet i després la travessem mitjançant un iterador per mostrar els elements de la col·lecció.

# 2) LinkedHashSet

LinkedHashSet implementa una interfície establerta i amplia HashSet (referir la jerarquia de col·lecció). LinkedHashSet és la representació de llista enllaçada del conjunt d'interfícies. LinkedHashSet conté elements únics, però permet valors nuls.

A continuació es dóna la definició general de LinkedHashSet.

Set s2 = new LinkedHashSet();

A continuació es dóna la implementació de LinkedHashSet.

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

Sortida:

LinkedHashSet

Una vegada més fem ús de títols de llibres per crear Linkedhashset. Com es pot veure a la sortida, linkedHashSet manté l'ordre d'addició.

Interfície SortedSet

La interfície SortedSet permet ordenar completament els elements. Conté mètodes que proporcionen un ordenament natural dels elements. Els elements de la col·lecció que implementen la interfície SortedSet es disposen en ordre creixent.

La classe TreeSet és un dels exemples que implementa la interfície SortedSet.

Conjunt d’arbres

La definició general de Treeset és la següent:

Set s3 = new TreeSet();

TreeSet implementa la interfície SortedSet i conté elements únics. L'emmagatzematge i recuperació són bastant ràpids i els elements es disposen en ordre ascendent.

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

Sortida:

Conjunt d’arbres

Al programa anterior, vam crear i afegir números senars a la col·lecció mitjançant mètodes add. A continuació, mitjançant un iterador, sortim els elements de la col·lecció.

Avantatges de Java Collections Framework

Programació reduïda: El marc de col·leccions inclou totes les interfícies i classes que contenen els mètodes que poden permetre als programadors escriure un programa eficient. D'aquesta manera, el programador no ha de centrar-se en massa programació.
Mètodes i API coherents: Totes les classes tenen mètodes comuns que actuen sobre les dades. Aquestes API són coherents a totes les classes i el programador no s’ha de preocupar de tenir massa mètodes diferents per a cada classe.
Augmenteu la velocitat i la precisió: Podeu escriure programes altament eficients mitjançant un marc de col·lecció i també programes més ràpids i precisos, ja que el marc de col·lecció proporciona la funcionalitat completa per implementar les estructures de dades i les col·leccions.
Facilita la reutilització del programari: Les estructures de dades i els algoritmes del marc de recopilació de Java són reutilitzables.
Interoperabilitat entre API no relacionades: Les API de col·lecció permeten la interoperabilitat fins i tot entre les API no relacionades.
Menys esforços per dissenyar noves API: Els programadors poden utilitzar les API de col·lecció estàndard i dissenyar noves API basades en això. No han de lluitar per escriure noves API completes.

Preguntes freqüents

# 1) Què utilitza un marc de col·lecció a Java?

Resposta: El framework de col·lecció ofereix algorismes, interfícies i classes preenvasats que permeten als programadors escriure programes altament eficients que poden emmagatzemar i processar dades.

# 2) Per què la col·lecció és un marc?

Resposta: Un framework és una col·lecció reutilitzable de classes, interfícies i algorismes. El marc de recopilació també és una col·lecció reutilitzable de classes d’estructures de dades i algorismes que operen en aquestes classes.

# 3) Què és l'API Java Collections a Java?

Resposta: L’API Java collections proporciona interfícies i classes que es poden ampliar i implementar per tal d’utilitzar estructures de dades que no són més que col·leccions.

# 4) Quina diferència hi ha entre col·lecció i col·leccions a Java?

Resposta: La col·lecció és una interfície base en el marc de col·lecció, mentre que 'col·leccions' és una classe. Tots dos formen part del paquet java.util.

**** Més detalls i exemples de Java Collections Framework: ****

Interfície de col·lecció Java

Comparació entre llista, conjunt i cua:

Llista	Conjunt	Cua
Es manté l'ordre d'inserció	L'ordre d'inserció no es manté al conjunt de hash	Es manté l'ordre d'inserció.
Pot contenir elements duplicats	No pot contenir elements duplicats	Pot contenir elements duplicats.
La inserció i eliminació de matriu es pot fer per a qualsevol índex.	Traieu l'element especificat.	Només es pot sortir l'últim element inserit. A més, la inserció d’elements es produeix al final.

Classe de llista de matrius

A Array, l'assignació de memòria està fixa. Però a ArrayList, la memòria es pot assignar dinàmicament. Aquesta classe ArrayList manté l'ordre d'inserció i podeu inserir elements duplicats.

Programa de demostració de la llista de matrius:

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

Classe de llista de matrius

Classe LinkedList

L'estructura de dades de la llista enllaçada conté nodes i aquest node contindrà dues parts:

ordres unix amb exemples i sintaxi

Dades
Referència al següent element

El primer node no és un node separat. Només conté la referència i s’anomena cap. L'últim node és nul.

Classe de llista enllaçada

Programa de demostració:

 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 
  Cua 
 Una cua és l'estructura de dades First in First Out (FIFO). Si crideu al mètode d'eliminació, sempre s'eliminarà el primer element inserit de la cua. Per tant, la cua s’utilitza en aplicacions en temps real on s’ha de recuperar les dades en l’ordre inserit.
  Exemple de programa: 
 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); } }  
  Conjunt 
 Una col·lecció establerta no permetrà elements duplicats. Podeu utilitzar una estructura de dades establerta quan vulgueu processar la recopilació de dades sense duplicar-la i quan no calgui mantenir l'ordre d'inserció.
  Programa de demostració: 
 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)); ; } }  
  Interfície MAP 
  Quan vulgueu la recopilació d’elements de processos amb el parell de claus i valors, podeu utilitzar l’estructura de dades del mapa, ja que el mapa és un objecte que pot assignar claus a valors.
 Un mapa no pot contenir claus duplicades.
 Les implementacions importants del mapa són HashMap, Treemap, LinkedHashMap, HashTable.
 
  Diferència entre HashMap, Treemap, LinkedHashMap i HashTable: 
   HashMap Mapa d’arbres LinkedHashmap HashTable  
 
   
  Es permeten claus i valors nuls Només es permeten valors nuls. Es permeten claus i valors nuls. No permetrà valors i claus nuls.  
  No sincronitzat No sincronitzat No sincronitzat sincronitzada  
  No hi ha cap garantia per mantenir l'ordre a la iteració L’ordenació es farà en funció de l’ordre natural. Es mantindrà l'ordre d'inserció L'ordre d'inserció no es manté.  
 
 
  Programa de demostració: 
 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); } }  
  Punts clau que cal tenir en compte: 
  La llista, la cua, les interfícies establertes amplien la interfície de col·lecció i aquesta interfície de col·lecció té mètodes comuns com afegir, eliminar, etc.
 L'ordre d'inserció es manté a la llista i un conjunt no pot contenir elements duplicats. La cua és l'estructura de dades First in First out.
 El mapa contindrà parells de claus i de valors. HashMap, Treemap, Hashtable, Linked HashMap són la implementació important de la interfície del mapa.
 
 Conclusió
 Aquest tutorial ens va donar una introducció al Java Collections Framework. Vam tocar breument totes les classes i interfícies que formen part del marc de col·lecció Java.
 En els nostres tutorials posteriors d’aquesta sèrie, coneixerem detalladament cadascuna d’aquestes classes i interfícies.
   Podeu explorar més sobre Reflexions a JAVA al nostre proper tutorial !!!  
   PREV Tutorial | NEXT Tutorial  
  Lectura recomanada
    Tutorial de reflexió de Java amb exemples  
  Tutorials Eclipse en profunditat per a principiants  
  Tutorial Java SWING: Gestió de contenidors, components i esdeveniments  
  Tutorial JAVA per a principiants: més de 100 tutorials pràctics de vídeo Java  
  Modificadors d'accés a Java: tutorial amb exemples  
  Java String amb buffer de cadenes i tutorial de Generador de cadenes  
  Introducció al llenguatge de programació Java: vídeo tutorial  
  Tutorial de Cogombre Selenium: Integració de Cogombre Java Selenium WebDriver