Course Collezioni Java - Lecture: Interfacce di raccolta

"Ciao, Amico!"

"Ciao, Eli!"

"Oggi ci occuperemo una volta per tutte della struttura delle collezioni".

"Ho aspettato a lungo per questo."

"Sai già cosa sono le raccolte e sai come lavorare con esse. È tempo di organizzare le tue conoscenze in un sistema rigoroso. Quindi molte domande sul "perché" e sul "come" spariranno e la maggior parte delle cose diventerà ovvia".

" Interfacce di raccolta . La struttura di ereditarietà delle interfacce di raccolta è simile a questa:"

Nota due cose.

Innanzitutto, tutto ciò che vedi qui è un'interfaccia.

In secondo luogo, le frecce significano «eredita».

"In altre parole, List, Set e Queue ereditano Collection, ma Map no?"

"Sì. Le classi astratte ereditano quindi queste interfacce e, a loro volta, le implementazioni che conosci ereditano quelle classi astratte: ArrayList, Hashtable, TreeSet,… "

"Hai ragione."

"Ora vediamo a cosa servono i metodi di queste interfacce:"

Metodi dell'interfaccia Iterable<E> ::

Metodi	Descrizione
`Iterator<T> iterator();`	Restituisce un oggetto iteratore.

"Non mi sembra abbastanza."

"Beh, ecco quanti ce ne sono. Questo è tutto per gli iteratori. Non li copriremo ora, ma li tratteremo in dettaglio presto."

Metodi dell'interfaccia Collection<E> ::

Metodi	Descrizione
`boolean add(E e);`	Aggiunge un elemento alla raccolta
`boolean addAll(Collection<? extends E> c);`	Aggiunge elementi alla raccolta
`void clear();`	Rimuove tutti gli elementi dalla raccolta
`boolean contains(Object o);`	Verifica se la raccolta contiene l'elemento.
`boolean containsAll(Collection<?> c);`	Verifica se la raccolta contiene gli elementi.
`boolean equals(Object o);`	Verifica se le raccolte sono equivalenti
`int hashCode();`	Restituisce il codice hash
`boolean isEmpty();`	Verifica se la raccolta è vuota.
`Iterator<E> iterator();`	Restituisce un oggetto iteratore
`boolean remove(Object o);`	Rimuove un elemento dalla raccolta
`boolean removeAll(Collection<?> c);`	Rimuove gli elementi dalla raccolta
`boolean retainAll(Collection<?> c);`	Rimuove tutti gli elementi non in c
`int size();`	Restituisce la dimensione della raccolta
`Object[] toArray();`	Converte la raccolta in una matrice
`<T> T[] toArray(T[] a);`	Converte la raccolta in una matrice

"Sono già solido su tutto qui. Ho usato metà di questi metodi e ho incontrato l'altra metà."

"Bene, andiamo avanti allora."

Metodi dell'interfaccia List<E> ::

Metodi	Descrizione
`void add(int index, E element);`	Aggiunge elementi al centro della raccolta
`boolean addAll(int index, Collection<? extends E> c);`	Aggiunge elementi alla raccolta
`E get(int index);`	Restituisce un elemento per indice
`int indexOf(Object o);`	Restituisce l'indice (numero) di un elemento
`int lastIndexOf(Object o);`	Restituisce l'indice dell'ultimo elemento.
`ListIterator<E> listIterator();`	Restituisce un iteratore per l'elenco
`ListIterator<E> listIterator(int index);`	Restituisce un iteratore per l'elenco
`E remove(int index);`	Rimuove un elemento in base al suo indice
`E set(int index, E element);`	Imposta un nuovo valore per indice
`List<E> subList(int fromIndex, int toIndex);`	Restituisce una sottoraccolta

"Niente di radicalmente nuovo neanche qui. So già quasi tutto delle collezioni, di cui non posso fare a meno di essere felice".

"Beh, penso di poter trovare qualcosa che ti sorprenderà. Ma continuiamo a esaminare le interfacce:"

Metodi dell'interfaccia Set<E> ::

Metodi	Descrizione
Nessun metodo

"L'interfaccia Set non ha nuovi metodi, solo quelli che eredita."

"Sì, ho visto che anche l'interfaccia Interable non aveva nulla.

"D'altra parte, meno metodi significano meno da ricordare!"

"Il tuo ottimismo che afferma la vita mi rende felice."

"L'interfaccia Set è ereditata da due interfacce con metodi: SortedSet e NavigableSet. Ma non li esaminerò o non finiremo mai."

"Invece, lascia che ti dia un quadro generale delle classi e delle interfacce che descrivono le raccolte in Java."

"Prendilo."

"Allora tieniti forte:"

"Wow, è enorme!"

"Beh, non è così grande. Inoltre, ricorda che le classi astratte sono del tutto facoltative. Ma è bene ricordare quale classe implementa quali interfacce. Questo può tornare utile abbastanza spesso."

"Oh, vorrei anche sottolineare che alcune collezioni sono considerate obsolete."

"Quali sono quelli?"

"Sto parlando delle classi Vector, Stack, Dictionary e Hashtable. Queste sono versioni sincronizzate (thread-safe) di raccolte ordinarie."

"Ma Java ha aggiunto una speciale libreria di concorrenza con molte raccolte a cui non solo è possibile accedere da altri thread, ma hanno anche un'implementazione molto più efficiente. ConcurrentHashMap è molto più efficiente di Hashtable ."

"Puoi utilizzare le raccolte Vector, Stack, Dictionary e Hashtable, ma non è consigliabile."

"Ho capito, lo terrò a mente."

"Grazie, Eli!"