java collections framework tutorial
Questo tutorial spiega in dettaglio Java Collections Framework (JCF) insieme a Gerarchia di raccolte, varie interfacce e i vantaggi di JCF:
Spero che questi eloquenti tutorial su questo Serie Java per principianti sono davvero utili per arricchire la tua conoscenza di Java.
Il nostro tutorial precedente ha fornito ulteriori informazioni sul operazioni di I / O di base in Java . In questo tutorial impareremo in dettaglio Java Collections Framework (JCF).
Java Collections Framework (JCF) contiene interfacce, classi astratte e classi che possono fornire l'architettura per memorizzare e manipolare un gruppo di oggetti.
Cosa imparerai:
- Tutorial video su Java Collections Framework
- Conclusione
Tutorial video su Java Collections Framework
Conoscenza di Arraylist in Java:
Imposta interfaccia e interfaccia coda in Java con esempi in tempo reale:
HashMap, TreeMap e HashTable in Java:
Finora abbiamo visto variabili che memorizzano diversi tipi di dati. Queste sono unità singole e non sono molto utili quando si hanno enormi quantità di dati da archiviare e gestire. Come sappiamo, i dati sono l'elemento più importante dell'elaborazione del computer.
La tua applicazione deve essere in grado di estrarre e raccogliere dati, elaborarli per trovare informazioni utili e anche passarli avanti e indietro in modo che vengano utilizzati in modo efficiente per raggiungere le soluzioni.
In questo mondo del software, archiviamo i dati che devono essere strutturati in un modo particolare in modo che i programmi software siano in grado di memorizzare, leggere, elaborare e infine produrre i risultati. Questo viene fatto utilizzando strutture dati.
Quasi tutti i linguaggi di programmazione supportano strutture dati. La struttura dei dati può essere definita come una rappresentazione strutturata dei dati. I linguaggi di programmazione forniscono funzioni API (Application Programming Interface) per manipolare le strutture dati.
Need For Collection Framework
Prima di Java 1.2, il linguaggio di programmazione Java supportava strutture di dati come array, vettori o tabelle hash. L'esecuzione di operazioni su queste strutture dati non è stata facile in quanto non esisteva un'interfaccia comune che funzionasse su queste strutture dati.
I programmatori trovavano difficile scrivere algoritmi che funzionassero per tutte le strutture di dati ed era una grande seccatura. Era necessaria un'interfaccia comune che funzionasse in modo coerente su tutte le strutture di dati e che eseguisse anche le operazioni in modo efficiente.
Successivamente, Java ha ideato un framework di raccolte che è un gruppo di classi e interfacce costituito da varie operazioni che possono essere eseguite su strutture di dati.
In questo tutorial sulle raccolte Java, discuteremo del framework delle raccolte Java in generale. Esploreremo ciascuno dei componenti della raccolta nei nostri prossimi tutorial.
Java Collections Framework
Prima di definire un Java Collections Framework, vediamo il significato di collection e di un framework.
Una raccolta può essere definita come un gruppo di oggetti. Una collezione è solitamente una singola unità composta da più di un oggetto. Un framework è un software che ha un'interfaccia o un'architettura funzionale già pronta e contiene anche un insieme di classi e interfacce da utilizzare con l'interfaccia fornita.
Un framework di collezioni è definito come un'architettura unificata e pronta, composta da quanto segue.
# 1) Algoritmi
Si tratta di metodi o set di istruzioni che possono aiutare i programmatori nella ricerca, nell'ordinamento e nell'elaborazione dei dati raccolti. La raccolta viene fornita con interfacce, classi e algoritmi.
Le applicazioni sviluppate ereditando il framework di raccolta hanno accesso a questi algoritmi e utilizzano metodi e procedure già definiti.
# 2) Interfacce
Le interfacce in Java forniscono l'astrazione dell'implementazione, ovvero utilizzando le interfacce, l'utente non è a conoscenza dei dettagli dell'implementazione, ma può solo vedere i metodi ei dati richiesti per scrivere un'applicazione. L'interfaccia di raccolta ha molte interfacce che possono essere implementate dal programmatore per scrivere le proprie classi.
# 3) Classi
Le classi di Collection Framework sono strutture di dati che possono essere implementate in un programma. Queste classi implementano l'interfaccia 'Collection' e quindi ereditano tutti i metodi e le definizioni dell'interfaccia di raccolta.
Un framework di raccolta viene utilizzato per archiviare e manipolare la raccolta che è il gruppo di oggetti.
Il framework di raccolta Java è costituito da algoritmi ad alte prestazioni che eseguono operazioni standard come ricerca, ordinamento ed elaborazione. Fornisce varie implementazioni standard tra cui LinkedList, TreeSet e HashSet per le quali vengono fornite le interfacce.
Successivamente, vediamo la gerarchia della raccolta Java.
Gerarchia della raccolta Java
Tutte le classi e le interfacce mostrate nella gerarchia della raccolta Java di seguito appartengono al pacchetto 'java.util. *'.
Come mostrato nel diagramma sopra, la gerarchia della raccolta Java è costituita da varie classi e interfacce. Come puoi vedere, ciascuna delle classi eredita da un'interfaccia e tutte le classi e le interfacce, a loro volta, ereditano da una singola interfaccia di 'raccolta'.
Discutiamo alcuni metodi comuni nell'interfaccia della raccolta insieme a una breve introduzione su ciascuna delle classi e interfacce mostrate nella gerarchia precedente.
Interfaccia di raccolta
L'interfaccia Collection è l'interfaccia di root. Tutte le classi nel framework di raccolta implementano l'interfaccia di raccolta. Ciò significa che ogni raccolta avrà i metodi dichiarati nell'interfaccia Collection.
Di seguito sono riportati alcuni dei metodi dell'interfaccia Collection.
No | Metodo Prototipo | Descrizione |
---|---|---|
7 | booleano predefinito removeIf (filtro predicato) | Rimuovi tutti gli elementi che soddisfano il 'filtro' del predicato specificato dalla raccolta. |
uno | public int size () | Restituisce il numero di elementi in una data raccolta. |
Due | public void clear () | Cancella la raccolta rimuovendo tutti gli elementi dalla raccolta. |
3 | public boolean add (E e) | Inserisce un elemento e nella raccolta. |
4 | public booleanaddAll (Collezione c) | Inserisce tutti gli elementi della collezione data da c nella collezione. |
5 | public boolean remove (Object element) | Elimina l'elemento fornito da 'elemento' dalla raccolta. |
6 | public boolean removeAll (Collectionc) | Rimuovere la raccolta c dalla raccolta. |
8 | public booleanretainAll (Collezione c) | Elimina tutti gli elementi dalla raccolta tranne quelli nella raccolta specificata c. |
9 | iteratore iteratore pubblico () | Restituisce l'iteratore per la raccolta. |
10 | public Object () toArray () | Converti la raccolta in un array. |
undici | public T () toArray (T () a) | Converti la raccolta in una matrice con un tipo restituito specificato. |
12 | public boolean isEmpty () | Restituisci se la raccolta è vuota o meno. |
13 | public boolean contains (Object element) | Controlla se una raccolta contiene l'elemento dato (operazione di ricerca). |
14 | public booleancontainsAll (Collectionc) | Controlla se la raccolta contiene la raccolta specificata c al suo interno. |
quindici | Spliterator spliterator predefinito () | Restituisce lo spliterator su una raccolta specificata. |
16 | public booleanequals (elemento Object) | Utilizzato per abbinare due collezioni. |
17 | predefinito Stream parallelStream () | Restituisce il flusso parallelo utilizzando la raccolta come origine. |
18 | Streamstream predefinito () | Restituisce un flusso sequenziale utilizzando la raccolta come origine. |
19 | public int hashCode () | Restituisce il codice hash numerico della raccolta. |
Interfaccia iterabile
L'interfaccia Iterable è anche l'interfaccia di base del framework di raccolta. L'interfaccia Collection che è l'interfaccia genitore di tutte le altre classi estende l'interfaccia Iterable. Quindi tutte le classi implementano un'interfaccia di raccolta e un'interfaccia Iterable.
L'interfaccia Iterable ha un solo metodo iterator () che restituisce l'iterator () che puoi usare per iterare sugli elementi di tipo T.
Iterator iterator ()
Interfaccia iteratore
L'interfaccia Iterator offre la possibilità di iterare sugli elementi in una direzione in avanti.
I seguenti sono i metodi supportati da questa interfaccia.
No | Metodo Prototipo | Descrizione |
---|---|---|
uno | public Object next () | Prima restituisce l'elemento e quindi sposta il cursore in modo che punti all'elemento successivo. |
Due | public boolean hasNext () | Controlla se l'iteratore ha più elementi. |
3 | public void remove () | Rimuove l'elemento restituito dall'iteratore alla fine. |
Interfaccia elenco
L'interfaccia dell'elenco eredita l'interfaccia della raccolta. L'interfaccia elenco contiene le strutture di dati utilizzate per memorizzare i dati ordinati o la raccolta di oggetti. Queste strutture dati sono di tipo elenco. Queste strutture di dati che implementano l'interfaccia elenco possono o non possono avere valori duplicati.
L'interfaccia elenco contiene i metodi utilizzati per accedere, inserire o rimuovere elementi dagli oggetti dell'elenco.
Le varie classi che implementano l'interfaccia List sono le seguenti:
cos'è un file .jnlp
- Lista di array
- Lista collegata
- Vettore
- Pila
Discuteremo brevemente ciascuna di queste classi. I nostri argomenti successivi avranno una discussione dettagliata su ciascuna delle classi del framework di raccolta.
# 1) ArrayList
ArrayList è l'implementazione più semplice dell'interfaccia List. ArrayList conserva l'ordine di inserimento e non è sincronizzato.
La definizione generale della struttura dati di ArrayList (Collection) è la seguente:
List list1= new ArrayList ();
Una volta definito l'elenco, è possibile utilizzare il metodo 'add' per aggiungere elementi. Notare che internamente ArrayList utilizzava un meccanismo di array dinamico.
Vedere i seguenti esempi che creano una raccolta di colori 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()); } } }
Produzione:
Il programma sopra mostra la dimostrazione della raccolta ArrayList. Aggiungiamo valori di colore alla raccolta e quindi attraversiamo la raccolta per visualizzare i singoli valori nella raccolta utilizzando un iteratore.
# 2) LinkedList
La raccolta LinkedList utilizza internamente un meccanismo di elenco doppiamente collegato per la memorizzazione degli elementi. Può contenere elementi duplicati. Le operazioni di raccolta di LinkedList sono più veloci in quanto non è richiesto lo spostamento degli elementi.
La definizione generale della creazione di un elenco collegato è la seguente:
List list2 = new LinkedList ();
Il seguente programma dimostra la raccolta di elenchi collegati di nomi di numeri .
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()); } } }
Produzione:
Pertanto, creiamo un elenco collegato e quindi aggiungiamo elementi ad esso utilizzando il metodo 'add'. Quindi, utilizzando un iteratore, attraversiamo l'elenco collegato e visualizziamo ogni elemento.
# 3) Vettore
Vector è simile a ArrayList e utilizza un array dinamico per memorizzare gli elementi come ArrayList. Ma il vettore supporta molti metodi indipendenti oltre alla raccolta che lo rende una scelta migliore per essere una raccolta preferita.
La definizione generale per la raccolta di vettori è:
List list3 = new Vector();
Notare che sebbene vector e ArrayList utilizzino lo stesso meccanismo degli array dinamici, gli elementi del vettore sono sincronizzati.
Il programma Java fornito di seguito dimostra l'uso di vettori nel framework di raccolta .
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()); } } }
Produzione:
In questo programma, abbiamo definito una raccolta di vettori composta da soggetti. Aggiungiamo vari soggetti e quindi usiamo un iteratore per produrre gli elementi.
# 4) Stack
La struttura dei dati dello stack implementa il modo LIFO (last-in-first-out) di inserire gli elementi. Lo stack è una sottoclasse del vettore di classe (fare riferimento al diagramma della gerarchia della raccolta sopra). Oltre ai propri metodi, la raccolta di stack supporta anche i metodi di raccolta di vettori.
La definizione generale della raccolta Stack è:
List list4 = new Stack();
Il seguente programma implementa la raccolta 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() + ' '); } } }
Produzione:
Come puoi vedere nell'implementazione sopra, i nuovi elementi vengono aggiunti allo stack utilizzando il 'spingere' operazione. Lo stack ha un unico punto di ingresso chiamato 'Top of the stack' e gli elementi vengono inseriti nello stack in alto. Pertanto, l'ultimo elemento aggiunto è in cima alla pila.
Come l'aggiunta, anche gli elementi vengono rimossi da un'estremità, ovvero in cima alla pila. Per rimuovere elementi, viene utilizzata un'operazione 'pop'. Quindi, se chiami pop (), l'elemento in cima allo stack verrà rimosso.
Nell'output sopra, inseriamo l'elemento 2, 4, 6,8,10 e quindi chiamiamo pop () in modo che 10 venga rimosso.
Interfaccia della coda
Le raccolte derivate dall'interfaccia della coda seguono l'ordine FIFO (first-in-first-out). Gli elementi vengono inseriti a un'estremità e vengono rimossi dall'altra estremità. Quindi l'elemento inserito per primo sembra essere l'elemento rimosso per primo.
Di seguito sono riportate le raccolte che supportano l'interfaccia di query.
- PriorityQueue
- e interfaccia
- ArrayDeque
Discutiamo brevemente ciascuno di questi.
# 1) PriorityQueue
Nella raccolta PriorityQueue, gli elementi memorizzati vengono elaborati in base alle loro priorità. Non è possibile memorizzare valori nulli nella coda di priorità.
La definizione generale della coda di priorità è la seguente:
Queue q1 = new PriorityQueue();
Il programma seguente implementa la coda di priorità.
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() + ' '); } } }
Produzione:
Ancora una volta usiamo i colori come elementi della coda di priorità. Nel programma sopra, abbiamo usato i metodi add e remove per aggiungere rispettivamente elementi alla coda e rimuovere un elemento. Usiamo il metodo peek () che restituisce un elemento a cui punta nella coda di priorità.
Infine, utilizzando un iteratore, vengono visualizzati gli elementi della coda di priorità.
# 2) interfaccia touch
Deque o una 'coda a doppia estremità' è una struttura di dati che consente di aggiungere e rimuovere gli elementi da entrambe le estremità. L'interfaccia deque nel framework della raccolta Java che estende l'interfaccia Queue.
migliore spia del cellulare per Android
Fornisce la funzionalità di deque e ha una classe 'ArrayDeque' che eredita da essa.
# 3) ArrayDeque
ArrayDeque implementa l'interfaccia deque.
La definizione generale di ArrayDeque è la seguente:
Deque d = new ArrayDeque();
ArrayDeque ti consente di utilizzare le funzionalità di Deque. A differenza di altre raccolte come ArrayList o stack, ArrayDeque non ha restrizioni sulla sua capacità.
L'esempio seguente mostra l'implementazione di 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); } } }
Produzione:
Nel programma precedente, definiamo una raccolta ArrayDeque di tipo integer e aggiungiamo elementi interi ad essa utilizzando il metodo add. La raccolta viene quindi attraversata utilizzando il costrutto for.
Imposta interfaccia
L'interfaccia set fa parte del pacchetto java.util e si estende dall'interfaccia collection. Set è una struttura che non consente alla raccolta di avere valori duplicati e anche più di un valore null.
Le seguenti classi implementano l'interfaccia set.
- HashSet
- LinkedHashSet
- TreeSet
# 1) HashSet
La raccolta HashSet che implementa l'interfaccia Set contiene valori distinti memorizzati al suo interno. Questa raccolta utilizza la tecnica di hashing per archiviare gli elementi e utilizza la tabella hash per archiviare gli elementi.
T La definizione generale della raccolta HashSet è mostrata di seguito.
Set s1 = new HashSet();
Abbiamo fornito l'implementazione di HashSet nel seguente programma.
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()); } } }
Produzione:
Nel programma sopra, creiamo una raccolta di soggetti HashSet e quindi la attraversiamo utilizzando un iteratore per visualizzare gli elementi nella raccolta.
# 2) LinkedHashSet
LinkedHashSet implementa un'interfaccia set ed estende HashSet (gerarchia di raccolte di riferimenti). LinkedHashSet è la rappresentazione dell'elenco collegato dell'interfaccia Set. LinkedHashSet contiene elementi univoci ma consente valori null.
La definizione generale di LinkedHashSet è fornita di seguito.
Set s2 = new LinkedHashSet();
L'implementazione per LinkedHashSet è fornita di seguito.
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()); } } }
Produzione:
Ancora una volta utilizziamo i titoli dei libri per creare Linkedhashset. Come puoi vedere dall'output, l'ordine di aggiunta è mantenuto da linkedHashSet.
Interfaccia SortedSet
L'interfaccia SortedSet consente l'ordinamento completo degli elementi. Contiene metodi che forniscono un ordinamento naturale degli elementi. Gli elementi nella raccolta che implementano l'interfaccia SortedSet sono disposti in ordine crescente.
La classe TreeSet è uno degli esempi che implementa l'interfaccia SortedSet.
Treeset
La definizione generale di Treeset è la seguente:
Set s3 = new TreeSet();
TreeSet implementa l'interfaccia SortedSet e contiene elementi univoci. La memorizzazione e il recupero sono abbastanza veloci e quindi gli elementi vengono disposti in ordine crescente.
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() + ' '); } } }
Produzione:
Nel programma sopra, abbiamo creato e aggiunto numeri dispari alla raccolta utilizzando metodi di aggiunta. Quindi utilizzando un iteratore, produciamo gli elementi nella raccolta.
Vantaggi di Java Collections Framework
- Programmazione ridotta: Il framework Collections viene fornito con tutte le interfacce e le classi contenenti i metodi che possono consentire ai programmatori di scrivere un programma efficiente. In questo modo, il programmatore non deve concentrarsi su una programmazione eccessiva.
- Metodi e API coerenti: Tutte le classi hanno metodi comuni che agiscono sui dati. Queste API sono coerenti in tutte le classi e il programmatore non deve preoccuparsi di avere troppi metodi diversi per ogni classe.
- Aumenta velocità e precisione: È possibile scrivere programmi altamente efficienti utilizzando un framework di raccolta e anche programmi più veloci e accurati poiché il framework di raccolta fornisce la piena funzionalità per implementare le strutture e le raccolte di dati.
- Facilita il riutilizzo del software: Le strutture dati e gli algoritmi del framework di raccolta Java sono riutilizzabili.
- Interoperabilità tra API non correlate: Le API di raccolta consentono l'interoperabilità anche tra API non correlate.
- Meno sforzi per progettare nuove API: I programmatori possono utilizzare le API di raccolta standard e progettare nuove API basate su di esse. Non devono lottare per scrivere nuove API complete.
Domande frequenti
# 1) Qual è l'uso di un framework di raccolta in Java?
Risposta: Il framework di raccolta offre algoritmi, interfacce e classi preconfezionati che consentono ai programmatori di scrivere programmi altamente efficienti in grado di memorizzare ed elaborare dati.
# 2) Perché Collection è un framework?
Risposta: Un framework è una raccolta riutilizzabile di classi, interfacce e algoritmi. Il framework di raccolta è anche una raccolta riutilizzabile di classi di strutture dati e algoritmi che operano su queste classi.
# 3) Che cos'è l'API Java Collections in Java?
Risposta: L'API delle raccolte Java fornisce interfacce e classi che possono essere estese e implementate per utilizzare strutture di dati che non sono altro che raccolte.
# 4) Qual è la differenza tra raccolta e raccolta in Java?
Risposta: La raccolta è un'interfaccia di base nel framework della raccolta mentre 'raccolte' è una classe. Entrambi fanno parte del pacchetto java.util.
**** Maggiori dettagli ed esempi di Java Collections Framework: ****
Confronto tra List, Set e Queue:
Elenco | Impostato | Coda |
---|---|---|
L'ordine di inserzione viene mantenuto | L'ordine di inserzione non viene mantenuto nel set di hash | L'ordine di inserzione viene mantenuto. |
Può contenere elementi duplicati | Non può contenere elementi duplicati | Può contenere elementi duplicati. |
L'inserimento e la rimozione dell'array possono essere eseguiti per qualsiasi indice. | Rimuovi l'elemento specificato. | Solo l'ultimo elemento inserito può essere estratto. Inoltre, l'inserimento di elementi avviene alla fine. |
Classe elenco array
In Array, l'allocazione della memoria è fissa. Ma in ArrayList, la memoria può essere allocata dinamicamente. Questa classe ArrayList mantiene l'ordine di inserimento ed è possibile inserire elementi duplicati.
Programma demo per Array List:
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 LinkedList
La struttura dati dell'elenco collegato contiene nodi e questo nodo conterrà due parti:
- Dati
- Riferimento all'elemento successivo
Il primo nodo non è un nodo separato. Contiene solo il riferimento e si chiama testa. L'ultimo nodo è nullo.
Programma demo:
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 
Coda
Una coda è la struttura dati FIFO (first in first out). Se chiami il metodo remove, sempre il primo elemento inserito verrà rimosso dalla coda. Quindi, Queue viene utilizzato in un'applicazione in tempo reale in cui i dati devono essere recuperati nell'ordine di inserimento.
Programma di esempio:
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); } }

Impostato
Una raccolta di set non consentirà elementi duplicati. È possibile utilizzare una struttura dati impostata, quando si desidera elaborare la raccolta di dati senza duplicazioni e quando non è necessario mantenere l'ordine di inserimento.
Programma demo:
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)); ; } }

Interfaccia MAP
- Quando si desidera elaborare la raccolta di elementi con la coppia chiave e valore, è possibile utilizzare la struttura dei dati della mappa poiché la mappa è un oggetto che può mappare le chiavi ai valori.
- Una mappa non può contenere chiavi duplicate.
- Le importanti implementazioni di map sono HashMap, Treemap, LinkedHashMap, HashTable.
Differenza tra HashMap, Treemap, LinkedHashMap e HashTable:
HashMap TreeMap LinkedHashmap HashTable Sono consentiti valori e chiavi nulli Sono consentiti solo valori nulli. Chiavi e valori nulli consentiti. Non consentirà chiavi e valori nulli. Non sincronizzato Non sincronizzato Non sincronizzato sincronizzato Non vi è alcuna garanzia di mantenere l'ordine nell'iterazione L'ordinamento verrà effettuato in base all'ordine naturale. L'ordine di inserzione verrà mantenuto Ordine di inserzione non mantenuto.
Programma demo:
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); } }

Punti chiave da notare:
- List, Queue, set interfaces estendono l'interfaccia di raccolta e questa interfaccia di raccolta ha metodi comuni come aggiungi, rimuovi ecc.
- L'ordine di inserzione viene mantenuto nell'elenco e un set non può contenere elementi duplicati. La coda è la struttura dati First in First out.
- La mappa conterrà coppie chiave e valore. HashMap, Treemap, Hashtable, Linked HashMap sono l'implementazione importante dell'interfaccia della mappa.
Conclusione
Questo tutorial ci ha fornito un'introduzione a Java Collections Framework. Abbiamo toccato brevemente tutte le classi e le interfacce che fanno parte del framework della raccolta Java.
Nei nostri successivi tutorial di questa serie, impareremo in dettaglio su ciascuna di queste classi e interfacce.
Puoi esplorare di più su Reflections in JAVA nel nostro prossimo tutorial !!!
Tutorial PREV | PROSSIMO Tutorial
Lettura consigliata
- Tutorial Java Reflection con esempi
- Tutorial approfonditi su Eclipse per principianti
- Tutorial Java SWING: contenitore, componenti e gestione degli eventi
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici
- Modificatori di accesso in Java - Tutorial con esempi
- Java String con String Buffer e String Builder Tutorial
- Introduzione al linguaggio di programmazione Java - Tutorial video
- Esercitazione sul selenio di cetriolo: integrazione con WebDriver di selenio Java di cetriolo