1. Struttura della raccolta Java
2. Gerarchia del quadro di raccolta
3. Interfaccia di raccolta
4. Interfaccia iteratore

IL Raccolta a Giava è un framework che fornisce un'architettura per archiviare e manipolare il gruppo di oggetti.

Le raccolte Java possono eseguire tutte le operazioni eseguite su dati come ricerca, ordinamento, inserimento, manipolazione ed eliminazione.

Collezione Java indica una singola unità di oggetti. Il framework Java Collection fornisce molte interfacce (Set, List, Queue, Deque) e classi ( Lista di array , vettore, Lista collegata , PriorityQueue , HashSet, LinkedHashSet, TreeSet).

Cos'è la raccolta in Java

Una Collezione rappresenta una singola unità di oggetti, cioè un gruppo.

Cos'è un framework in Java

• Fornisce un'architettura già pronta.
• Rappresenta un insieme di classi e interfacce.
• È facoltativo.

Cos'è il framework Collection

Il framework Collection rappresenta un'architettura unificata per archiviare e manipolare un gruppo di oggetti. Esso ha:

1. Interfacce e sue implementazioni, ovvero classi
2. Algoritmo

• Quali sono i due modi per ripetere gli elementi di una raccolta?
• Qual è la differenza tra le classi ArrayList e LinkedList nel framework di raccolta?
• Qual è la differenza tra le classi ArrayList e Vector nel framework di raccolta?
• Qual è la differenza tra le classi HashSet e HashMap nel framework di raccolta?
• Qual è la differenza tra la classe HashMap e la classe Hashtable?
• Qual è la differenza tra l'interfaccia Iterator e Enumeration nel framework di raccolta?
• Come possiamo ordinare gli elementi di un oggetto? Qual è la differenza tra le interfacce Comparable e Comparator?
• Cosa significa il metodo hashcode()?
• Qual è la differenza tra la raccolta Java e le raccolte Java?

Gerarchia del quadro di raccolta

Vediamo la gerarchia del framework Collection. IL java.util il pacchetto contiene tutto il classi E interfacce per il quadro Collection.

Metodi di interfaccia di raccolta

Esistono molti metodi dichiarati nell'interfaccia Collection. Sono i seguenti:

Interfaccia iteratore

Metodi di interfaccia di Iterator

Esistono solo tre metodi nell'interfaccia Iterator. Sono:

Interfaccia iterabile

L'interfaccia Iterable è l'interfaccia root per tutte le classi di raccolta. L'interfaccia Collection estende l'interfaccia Iterable e quindi anche tutte le sottoclassi dell'interfaccia Collection implementano l'interfaccia Iterable.

Contiene un solo metodo astratto. cioè.,

 Iterator iterator() 

Restituisce l'iteratore sugli elementi di tipo T.

operatore resto Python

Interfaccia di raccolta

L'interfaccia Collection è l'interfaccia implementata da tutte le classi nel framework della raccolta. Dichiara i metodi che avrà ogni raccolta. In altre parole, possiamo dire che l'interfaccia Collection costituisce le basi da cui dipende il framework della raccolta.

Alcuni dei metodi dell'interfaccia Collection sono Boolean add ( Object obj), Boolean addAll ( Collection c), void clear(), ecc. che sono implementati da tutte le sottoclassi dell'interfaccia Collection.

Elenco interfaccia

L'interfaccia Elenco è l'interfaccia secondaria dell'interfaccia Raccolta. Inibisce una struttura dati di tipo elenco in cui possiamo memorizzare la raccolta ordinata di oggetti. Può avere valori duplicati.

L'interfaccia List è implementata dalle classi ArrayList, LinkedList, Vector e Stack.

Per istanziare l'interfaccia List, dobbiamo usare:

 List list1= new ArrayList(); List list2 = new LinkedList(); List list3 = new Vector(); List list4 = new Stack(); 

Esistono vari metodi nell'interfaccia Elenco che possono essere utilizzati per inserire, eliminare e accedere agli elementi dall'elenco.

Di seguito sono riportate le classi che implementano l'interfaccia List.

Lista di array

La classe ArrayList implementa l'interfaccia List. Utilizza un array dinamico per memorizzare l'elemento duplicato di diversi tipi di dati. La classe ArrayList mantiene l'ordine di inserimento e non è sincronizzata. È possibile accedere in modo casuale agli elementi memorizzati nella classe ArrayList. Considera il seguente esempio.

 import java.util.*; class TestJavaCollection1{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Ravi');//Adding object in arraylist list.add('Vijay'); list.add('Ravi'); list.add('Ajay'); //Traversing list through Iterator Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Produzione:

 Ravi Vijay Ravi Ajay 

Lista collegata

LinkedList implementa l'interfaccia Collection. Utilizza internamente un elenco doppiamente collegato per memorizzare gli elementi. Può memorizzare gli elementi duplicati. Mantiene l'ordine di inserimento e non è sincronizzato. In LinkedList, la manipolazione è veloce perché non è richiesto alcuno spostamento.

Considera il seguente esempio.

 import java.util.*; public class TestJavaCollection2{ public static void main(String args[]){ LinkedList al=new LinkedList(); al.add('Ravi'); al.add('Vijay'); al.add('Ravi'); al.add('Ajay'); Iterator itr=al.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Produzione:

 Ravi Vijay Ravi Ajay 

Vettore

Vector utilizza un array dinamico per memorizzare gli elementi di dati. È simile a ArrayList. Tuttavia, è sincronizzato e contiene molti metodi che non fanno parte del framework Collection.

Considera il seguente esempio.

 import java.util.*; public class TestJavaCollection3{ public static void main(String args[]){ Vector v=new Vector(); v.add('Ayush'); v.add('Amit'); v.add('Ashish'); v.add('Garima'); Iterator itr=v.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Produzione:

 Ayush Amit Ashish Garima 

Pila

Lo stack è la sottoclasse di Vector. Implementa la struttura dati last-in-first-out, ovvero Stack. Lo stack contiene tutti i metodi della classe Vector e fornisce anche i suoi metodi come boolean push(), boolean peek(), boolean push(object o), che ne definisce le proprietà.

Considera il seguente esempio.

 import java.util.*; public class TestJavaCollection4{ public static void main(String args[]){ Stack stack = new Stack(); stack.push('Ayush'); stack.push('Garvit'); stack.push('Amit'); stack.push('Ashish'); stack.push('Garima'); stack.pop(); Iterator itr=stack.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Produzione:

 Ayush Garvit Amit Ashish 

Interfaccia della coda

L'interfaccia della coda mantiene l'ordine first-in-first-out. Può essere definito come un elenco ordinato che viene utilizzato per contenere gli elementi che stanno per essere elaborati. Esistono varie classi come PriorityQueue, Deque e ArrayDeque che implementano l'interfaccia Queue.

L'interfaccia della coda può essere istanziata come:

 Queue q1 = new PriorityQueue(); Queue q2 = new ArrayDeque(); 

Esistono varie classi che implementano l'interfaccia Queue, alcune di esse sono riportate di seguito.

PriorityQueue

La classe PriorityQueue implementa l'interfaccia Queue. Contiene gli elementi o gli oggetti che devono essere elaborati in base alle loro priorità. PriorityQueue non consente l'archiviazione di valori null nella coda.

Considera il seguente esempio.

 import java.util.*; public class TestJavaCollection5{ public static void main(String args[]){ PriorityQueue queue=new PriorityQueue(); queue.add('Amit Sharma'); queue.add('Vijay Raj'); queue.add('JaiShankar'); queue.add('Raj'); System.out.println('head:'+queue.element()); System.out.println('head:'+queue.peek()); System.out.println('iterating the queue elements:'); Iterator itr=queue.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } queue.remove(); queue.poll(); System.out.println('after removing two elements:'); Iterator itr2=queue.iterator(); while(itr2.hasNext()){ System.out.println(itr2.next()); } } } 

Produzione:

 head:Amit Sharma head:Amit Sharma iterating the queue elements: Amit Sharma Raj JaiShankar Vijay Raj after removing two elements: Raj Vijay Raj 

E l'interfaccia

L'interfaccia Deque estende l'interfaccia Queue. In Deque possiamo rimuovere e aggiungere elementi da entrambi i lati. Deque sta per una coda a doppia estremità che ci consente di eseguire le operazioni su entrambe le estremità.

Deque può essere istanziato come:

 Deque d = new ArrayDeque(); 

ArrayDeque

La classe ArrayDeque implementa l'interfaccia Deque. Ci facilita l'uso della Deque. A differenza della coda, possiamo aggiungere o eliminare gli elementi da entrambe le estremità.

ArrayDeque è più veloce di ArrayList e Stack e non presenta limitazioni di capacità.

Considera il seguente esempio.

 import java.util.*; public class TestJavaCollection6{ public static void main(String[] args) { //Creating Deque and adding elements Deque deque = new ArrayDeque(); deque.add('Gautam'); deque.add('Karan'); deque.add('Ajay'); //Traversing elements for (String str : deque) { System.out.println(str); } } } 

Produzione:

 Gautam Karan Ajay 

Imposta l'interfaccia

Imposta interfaccia in Java è presente nel pacchetto java.util. Estende l'interfaccia della raccolta. Rappresenta l'insieme non ordinato di elementi che non ci consente di memorizzare gli elementi duplicati. Possiamo memorizzare al massimo un valore nullo in Set. Set è implementato da HashSet, LinkedHashSet e TreeSet.

Il set può essere istanziato come:

 Set s1 = new HashSet(); Set s2 = new LinkedHashSet(); Set s3 = new TreeSet(); 

HashSet

La classe HashSet implementa Set Interface. Rappresenta la raccolta che utilizza una tabella hash per l'archiviazione. L'hashing viene utilizzato per archiviare gli elementi nell'HashSet. Contiene oggetti unici.

Considera il seguente esempio.

 import java.util.*; public class TestJavaCollection7{ public static void main(String args[]){ //Creating HashSet and adding elements HashSet set=new HashSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); //Traversing elements Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Produzione:

 Vijay Ravi Ajay 

LinkedHashSet

La classe LinkedHashSet rappresenta l'implementazione LinkedList di Set Interface. Estende la classe HashSet e implementa l'interfaccia Set. Come HashSet, contiene anche elementi unici. Mantiene l'ordine di inserimento e consente elementi nulli.

Considera il seguente esempio.

 import java.util.*; public class TestJavaCollection8{ public static void main(String args[]){ LinkedHashSet set=new LinkedHashSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Produzione:

 Ravi Vijay Ajay 

Interfaccia SortedSet

SortedSet è l'alternativa dell'interfaccia Set che fornisce un ordinamento totale sui suoi elementi. Gli elementi del SortedSet sono disposti in ordine crescente (ascendente). SortedSet fornisce metodi aggiuntivi che inibiscono l'ordinamento naturale degli elementi.

Il SortedSet può essere istanziato come:

 SortedSet set = new TreeSet(); 

Set di alberi

La classe Java TreeSet implementa l'interfaccia Set che utilizza un albero per l'archiviazione. Come HashSet, anche TreeSet contiene elementi unici. Tuttavia, il tempo di accesso e recupero di TreeSet è piuttosto rapido. Gli elementi in TreeSet sono memorizzati in ordine crescente.

Considera il seguente esempio:

 import java.util.*; public class TestJavaCollection9{ public static void main(String args[]){ //Creating and adding elements TreeSet set=new TreeSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); //traversing elements Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Produzione:

 Ajay Ravi Vijay 

1. Classe ArrayList
2. Classe LinkedList
3. Interfaccia elenco
4. Classe HashSet
5. Classe LinkedHashSet
6. Classe TreeSet
7. Classe PriorityQueue
8. Interfaccia della mappa
9. Classe HashMap
10. Classe LinkedHashMap
11. Classe TreeMap
12. Classe hashtable
13. Ordinamento
14. Interfaccia comparabile
15. Interfaccia comparatore
16. Classe delle proprietà in Java