Marco Palena Prontuario di Programmazione a Oggetti: Java Collezioni

Collezioni Tipi di collezioni collezione non contiene alcun

elemento.
java.util Contiene le interfacce che definiscono le collezioni Interfaccia Descrizione Restituisce true se la
principali e le classi che le implementano. Interfaccia radice per le collezioni, collezione corrente contiene
java.lang Contiene l'interfaccia Iterable<E> mediante la quale Collection<E> fornisce metodi basilari comuni a l'oggetto elem. Cioè se
è possibile creare iteratori, ovvero oggetti utilizzati tutte le collezioni.
boolean contains(Object elem) contiene un qualche elemento
per scorrere il contenuto di una collezione. per cui l'invocazione di
Collezione nella quale non possono equals con elem restituisca
Gerarchia delle collezioni esistere elementi duplicati e gli true.
Le collezioni contenute nel package java.util rappresentano tipi Set<E> stessi elementi non sono
generici e si dividono principalmente in due gruppi: necessariamente memorizzati in un Restituisce un iteratore che
ordine specifico.
Iterator<E> iterator() permette di esaminare la
• Collezioni: implementano l'interfaccia Collection<E>; collezione corrente.
• Mappe: implentano l'interfaccia Map<K, V>; Collezione nella quale non possono
SortedSet<E> esistere elementi duplicati e gli Restituisce un nuovo array di
Object che contiene tutti gli
Iterable<E> stessi elementi sono ordinati. Object [] toArray()
elementi appartenenti alla
Collezione in cui gli elementi sono collezione corrente.
List<E> memorizzati in sequenza a meno
che la lista non venga modificata. Memorizza in dest gli
Collection<E>
elementi della collezione
Collezione in cui gli elementi sono corrente. Se dest può
HashSet<E> memorizzati in sequenza in cui contenere più elementi di
Queue<E>
l'elemento in testa è destinatario di quanti ne siano presenti nella
Set<E> EnumSet<E> operazioni particolari. collezione, alla prima
LinkedHashSet<E> posizione dopo quelle
Mappa che associa a una chiave
Map<K,V> occupate dagli elementi della
univoca al più un valore.
SortedSet<E> TreeSet<E> collezione viene assegnato
Mappa che associa a una chiave <T> T[] toArray(T[] dest) null. Se dest non è
Queue<E> PriorityQueue<E> SortedMap<K,V> univoca al più un valore abbastanza grande viene
mantenendo ordinate le chiavi. creato un nuovo array dello
stesso tipo che possa
Collection contenere gli elementi, viene
List<E> LinkedList<E> riempito e restituito. Se dest
Interfaccia generica di base per le collezioni. Definisce i metodi di
non è compatibile con i tipi
base per operare sulle collezioni. Tutti i meodi che richiedono la
di tutti gli elementi nella
ArrayList<E> nozione di equivalenza utilizzano il metodo equals degli oggetti
collezione viene sollevata
contenuti. Detto E il tipo di oggetti da memorizzare: ArrayStoreException.
EnumMap<K, V> boolean add(E elem) Aggiunge elem alla
Metodo Descrizione collezione. Ritorna true se
Map<K, V> HashMap<K, V>
Il numero di elementi l'aggiunta ha modificato la
LinkedHashMap<K, V> int size() contenuti dalla collezione collezione altrimenti false
corrente. (nel caso in cui la collezione
WeakHashMap<K, V>
non ammetta duplicati e al
boolean isEmpty() Restituisce true se la
SortedMap<K, V> TreeMap<K, V>
suo interno sia già presente

1
 Marco Palena Prontuario di Programmazione a Oggetti: Java Collezioni

un elemento equivalente a SortedSet

HashSet
elem).
Implementazione dell'interfaccia Set<E> mediante una tabella di
Interfaccia Implementazione Add Contains Next
Rimuove dalla collezione una hash. Un insieme può contenere un solo elemento null. Si appoggia
singola istanza di elem. su una HashMap<E>, pertanto gli elementi in essa contenuti SortedSet
TreeSet<E> O(logn) O(log n) O(log n)
boolean remove(Object elem) Restitusce true nel caso in necessitano di una funzione hashCode() efficiente. <E>
cui la rimozione modifichi la
collezione. Add Contains Next Interfaccia che estende Set<E> ridefinendone i metodi in modo da
Restituisce true se la mantenere una relazione d'ordine tra gli elementi inseriti. Di default
O(1) O(1) O(h/n) tale ordinamento è quello naturale degli elementi, cioè quello
boolean containsAll(Collection<?> collezione corrente contiene
coll) ognuno degli oggetti definito dal metodo compareTo(E elem) dell'interfaccia
contenuti in coll. Prevede i costruttori: Comparable<E>. In base alle implementazioni è anche possibile
definire un oggetto Comparator<E> da utilizzare per ordinare gli
Aggiunge alla collezione tutti Costruttore Descrizione elementi invece di ricorrere all'ordinamento naturale. Tale
gli oggetti contenuti in coll. interfaccia definisce metodi che hanno senso solo per insiemi
boolean addAll(Collection<? Crea un nuovo HashSet con
extends E> coll) Restituisce true se almeno ordinati:
una delle aggiunte ha HashSet(int capacity, float capacità iniziale della tabella di
modificato la collezione. loadFactor) hash capacity e fattore di
Metodo Descrizione
carico loadFactor.
Rimuove dalla collezione Restituisce il Comparator
tutti gli oggetti contenuti in Crea un nuovo HashSet con
boolean removeAll(Collection<?> utilizzato dall'insieme ordinato
coll. Restituisce true se capacità iniziale della tabella di Comparator<? super E>
coll) HashSet(int capacity)
comperator() corrente. Restituisce null se si
almeno una delle rimozioni hash capacity e fattore di
ricorre all'ordinamento naturale
ha modificato la collezione. carico di deafult (0,75).
degli elementi.
Rimuove dalla collezione Crea un nuovo HashSet con
Restituisce il primo oggetto (cioè
tutti gli oggetti che non sono capacità iniziale della tabella di
HashSet() E first() il minore) appartenente
boolean retainAll(Collection<?> presenti in coll. Restituisce hash di dafault e fattore di
all'insieme.
coll) true se almeno una delle carico di default (0,75).
rimozioni ha modificato la Restituisce l'ultimo oggetto (cioè
Crea un nuovo HashSet i cui
collezione. E last() il maggiore) appartenente
elementi iniziali sono quelli
all'insieme.
Rimuove tutti gli elementi contenuti in coll, la capacità
void clear() HashSet(Collection<? extends E>
dalla collezione corrente. coll) iniziale della tabella di hash è Restituisce il sottoinsieme
basata sulla dimensione di coll. contenente gli elementi contenuti
Il fattore di carico è quello di nell'insieme corrente maggiori o
Set default (0,75). uguali a min e minori di max.
L'insieme ritornato si appoggia
Interfaccia Implementazione Add Contains Next SortedSet<E> subSet(E min, E sull'insieme su cui tale metodo è
LinkedHashSet max)
HashSet<E> O(1) O(1) O(h/n) Estende HashSet<E> mantenendo collegamenti tra gli elementi in chiamato. La modifica degli
Set<E> elementi del primo insieme si
base all'ordine di inserimento. L'iterazione restituisce gli elementi
LinkedHashSet<E> O(1) O(1) O(1) riflette su quelle del secondo e
nell'ordine di inserimento, per il resto si comporta esattamente come
Nota: h è la capacità della tabella di hash. viceversa. Se min è maggiore di
HashSet<E>. Prevede costruttori nella medesima forma.
max viene lanciata una
Interfaccia che estende Collection<E> ridefinendone i metodi in Add Contains Next IllegalArgumentException.
modo da impedire la memorizzazione di elementi duplicati. Un O(1) O(1) O(1)
insieme può contenere un solo elemento null.

2
 Marco Palena Prontuario di Programmazione a Oggetti: Java Collezioni

TreeSet Interfaccia che estende Collection<E> allo scopo di definire una contenente gli elementi della
Implementazione dell'interfaccia SortedSet<E> mediante un albero collezione in cui ogni elemento esista in una particolare posizione lista corrente nelle posizioni
binario bilanciato. L'efficienza delle operazioni: all'interno della collezione. Le posizioni sono indicizzate a partire che vanno da min (compreso)
da 0 fino a size()-1. Quando si aggiunge un elemento questo viene a max (escluso). La lista
Add Contains Next situato in fondo alla lista, quando si rimuove l'n-esimo elemento si restituita si appoggia sulla
spostano in avanti tutti gli elementi che lo seguono. Il metodo lista su cui è chiamato,
O(log n) O(log n) O(log n) toArray() riempie l'array con gli elementi prelevandoli eventuali modifiche sulla
ordinatamente dalla lista. Definisce i metodi utili per una collezione prima si riflettono sulla
Prevede i costruttori: ordinata (gli elementi che richiedono un'indice possono sollevare seconda e viceversa.
l'eccezione IndexOutOfBoundsException):
Restituisce un oggetto
Costruttore Descrizione ListIterator che permette di
Metodo Descrizione
Crea un nuovo TreeSet ordinato ListIterator<E> listIterator(int iterare avanti o indietro fra
secondo l'ordinamento naturale Restituisce l'elemento in index) tutti gli elementi della lista a
E get(int index)
del tipo dei suoi elementi. Tutti posizione index nella lista. cominciare dalla posizione
TreeSet() gli elementi aggiunti devono index.
Assegna elem all'elemento in
implementare Comparable ed posizione index nella lista, Restituisce un oggetto
essere reciprocamente E set(int index)
sostituendo e restituendo il ListIterator che permette di
confrontabili. contenuto precedente. ListIterator<E> listIterator() iterare avanti o indietro fra
Crea un nuovo TreeSet ordinato tutti gli elementi della lista a
Aggiunge alla lista nella
secondo l'ordinamento naturale cominciare dalla posizione 0.
posizione index l'elemento
del tipo dei suoi elementi e con void add(int index, E elem)
elem, spostando in avanti
TreeSet(Collection<? extends E> elementi iniziali quelli ArrayList
coll)
tutti gli elementi successivi.
contenuti in coll. Tutti gli Implementazione dell'interfaccia List<E> mediante un array
elementi devono implementare Rimuove e restituisce
ridimensionabile. Tale implementazione è dodata di una capacità
Comparable ed essere l'elemento in posizione index
che misura il numero di elementi che possono essere contenuti senza
reciprocamente confrontabili. E remove(int index) nella lista, spostando tutti gli
dover allocare nuova memoria. Quando il numero di elementi
elementi successivi di una
Crea un nuovo TreeSet ordinato contenuti eguaglia la capacità viene allocato un nuovo array che
TreeSet(Comparator<? super E> posizione in avanti.
secondo l'ordinamento definito sostituisce il primo.
comparator)
da comparator. Restituisce l'indice del primo
oggetto nella lista che risulta Add Get Remove Contains Next Iterator.remove
Crea un nuovo TreeSet il cui equal a elem o che è null se
contenuto iniziale sarà lo stesso int indexOf(Object elem) O(1) O(1) O(n) O(n) O(1) O(n)
TreeSet(SortedSet<E> set) elem lo è. Restituisce -1 se
di set, ordinato secondo lo non è possibile trovare alcun
stesso ordinamento di set. oggetto adeguato. Prevede i costruttori:
Restituisce l'indice
List Costruttore Descrizione
dell'ultimo oggetto nella lista
che risulta equal a elem o Crea un nuovo ArrayList con
Interfaccia Implementazione Add Get Remove(0)* ArrayList()
int lastIndexOf(Object elem) che è null se elem lo è. capacità iniziale di default.
ArrayList<E> O(1) O(1) O(n) Restituisce -1 se non è
possibile trovare alcun Crea un nuovo ArrayList con
List<E>
LinkedList<E> O(1) O(n) O(1) oggetto adeguato.
ArrayList(int capacity) capacità iniziale pari a
capacity.
List<E> subList(int min, int max) Restituisce una sottolista

3
 Marco Palena
Crea un nuovo ArrayList con
contenuto iniziale pari al
contenuto di coll e capacità
ArrayList(Collection<? extends E> pari al 110% della dimensione
coll)
di coll. L'ordine con cui gli
elementi iniziali sono
memorizzati è quello restituito
dall'iteratore di coll.
LinkedList
Implementazione dell'interfaccia List<E> mediante una lista
doppiamente concatenata.
Add Get Remove Contains Next Iterator.remove
O(1) O(n) O(1) O(n) O(1) O(1)
Prevede i costruttori:
Costruttore Descrizione
Crea una nuova LinkedList
LinkedList()
vuota.
Crea un nuovo LinkedList con
contenuto iniziale pari al
LinkedList(Collection<? extends contenuto di coll. L'ordine con
E> coll) cui gli elementi iniziali sono
memorizzati è quello restituito
dall'iteratore di coll.
Definisce i metodi che permettono di lavorare efficacemente con le
liste doppiamente concatenate:
Metodo Descrizione
Restituisce il primo elemento
E getFirst()
della lista.
Restituisce l'ultimo elemento
E getLast()
della lista.
Rimuove e ritorna il primo
E removeFirst()
elemento della lista.
E removeLast() Rimuove e ritorna l'ultimo
Prontuario di Programmazione a Oggetti: Java
elemento della lista.
Aggiunge elem nella prima
void addFirst(E elem)
posizione della lista.
Aggiunge elem nell'ultima
void addLast(E elem)
posizione della lista.
Map
Interfaccia Implementazione Get containsKey Next
Map<K, V> HashMap<K, V> O(1) O(1) O(h/n)
Nota: h è la capacità della tabella di hash.
Interfaccia che definisce una collezione in cui ad essere
memorizzati non sono singoli elementi ma coppie chiave/valore.
Permette di ricercare i valori V memorizzati sotto una determinata
chiave K. Una chiave specifica può mapparsi su un valore o
nessuno. Un valore specifico può essere mappato su un numero di
chiavi ampio a piacere. I principali metodi sono:
Metodo Descrizione
Restituisce il numero di
int size() associazioni chiave/valore
contenute nella mappa.
Restituisce true se la mappa
boolean isEmpty()
è vuota.
Restituisce true se la mappa
boolean containsKey(Object key) contiene un valore associato
alla chiave key.
Restituisce true se la mappa
boolean containsValue(Object
value) contiene una chiave alla
quale è associato value.
V get(Object key) Restituisce l'oggetto
associato alla chiave key
altrimenti null se questa non
ha alcuna associazione.
Restituisce null anche nel
caso in cui key sia mappato
esattamente su tale valore,
all'interno di mappe che
4
Collezioni
ammettono valori null.
Associa key nella mappa al
valore value. Se esiste già
un'associazione per key il suo
valore viene modificato e si
V put(K key, V value)
restituisce il valore originale.
Se non esistono già altre
associazioni per la chiave
specifica restituisce null.
Rimuove le associazioni per
la chiave key. Se esiste
un'associazione per key
questa viene eliminata e si
V remove(Object key)
restituisce il valore a cui key
era associato. Se non esistono
associazioni per la chiave
specifica restituisce null.
Ricopia nella mappa tutte le
void putAll(Map<? extends K, ?
extends V> otherMap) associazioni presenti in
otherMap.
Elimina tutte le associazioni
void clear()
della mappa.
Restituisce un Set<K> i cui
elementi corrispondono alle
chiavi della mappa corrente.
Tale insieme è appoggiato
sulla mappa, la modifica
Set<K> keySet() degli elementi dell'insieme si
riflette su quelli della mappa
e viceversa. Tale insieme è
un'implementazione di Set
che non supporta gli
inserimenti.
Collection<V> values() Restituisce una
Collection<V> i cui elementi
corrispondono ali valori
presenti nella mappa
corrente. Tale collezione è
appoggiata sulla mappa, la
modifica degli elementi della
collezione si riflette su quelli
 Marco Palena
della mappa e viceversa. Tale
collezione è
un'implementazione di
Collection che non supporta
gli inserimenti.
Restituisce un Set i cui
elementi sono oggetti
Map.Entry<K,V> che
rappresentano singole
associazioni presenti nella
mappa. Tale insieme è
appoggiato sulla mappa, la
Set<Map.Entry<K,V>> entrySet()
modifica degli elementi
dell'insieme si riflette su
quelli della mappa e
viceversa. Tale insieme è
un'implementazione di Set
che non supporta gli
inserimenti.
Map.Entry
L'interfaccia Map<K,V> definisce un'interfaccia innestata
Map.Entry<K,V> che rappresenta come oggetti le associazioni
presenti nella mappa. Tale interfaccia innestata fornisce i metodi:
Metodo Descrizione
Restituisce la chiave
K getKey()
dell'elemento corrente.
Restituisce il valore
V getValue()
dell'elemento corrente.
Assegna un valore
V setValue(V value) all'elemento corrente e
restituisce il vecchio valore.
HashMap
Implementazione dell'interfaccia Map<K, V> mediante una tabella di
hash. Sfrutta il metodo hashCode() delle chiavi allo scopo di
SortedMap
individuare una posizione all'interno della stessa in cui inserire le
associaioni. Il metodo hashCode() delle chiavi deve essere definito
in modo efficiente. La tabella interna utilizzata consiste in un certo
numero di caselle inizialmente determinare in base alla capacità
iniziale della mappa stessa. Il codice hash delle chiavi stabilisce in
Prontuario di Programmazione a Oggetti: Java Collezioni
che caselle memorizzare le associazioni. Il fattore di carico Nota: h è la capacità della tabella di hash.
stabilisce il momento in cui verrà accresciuta automaticamente la
capacità della mappa hash. Quando il numero degli elementi Interfaccia che estende Map<K, V> ridefinendone la semantica in
modo da richiedere che le chiavi siano ordinate. Di default tale
contenuti nella mappa è maggiore del prodotto del fattore di carico
per la capacità corrente questa viene raddoppiata. Un incremento di ordinamento è quello naturale per le chiavi. In tal caso perciò esse
devono implementare l'interfaccia Comparable<K>.
capacità comporta il rehashing di tutte le associazioni presenti nella
mappa (operazione costosa). Il fattore di carico di default è 0,75. La Alternativamente l'ordinamento può essere definito mediante un
complessità delle operazioni è: comparatore Comparator<K>. L'ordinamento si rispecchia nei valori
restituiti da keySet(), values() ed entrySet().
SortedMap<K, V> fornisce metodi che hanno senso in una mappa
Get containsKey Next ordinata:
O(1) O(1) O(h/n)
Nota: h è la capacità della tabella di hash. Metodo Descrizione
Prevede i costruttori: Restituisce il Comparator
utilizzato dalla mappa
Comparator<? super K> ordinata corrente. Restituisce
Costruttore Descrizione comperator() null se si ricorre
Crea una nuova HashMap con all'ordinamento naturale delle
HashMap(int capacity, float capacità iniziale della tabella di chiavi.
loadFactor) hash capacity e fattore di
Restituisce la prima chiave
carico loadFactor.
(cioè quella di valore minore)
K firstKey()
Crea una nuova HashMap con all'interno della mappa
capacità iniziale della tabella di corrente.
HashMap(int capacity)
hash capacity e fattore di
Restituisce l'ultima chiave
carico di deafult (0,75). (cioè quella di valore
K lastKey()
Crea una nuova HashMap con maggiore) all'interno della
capacità iniziale della tabella di mappa corrente.
HashMap()
hash di dafault e fattore di
Restituisce la sottomappa
carico di default (0,75). contenente le associazioni le
Crea una nuova HashMap i cui cui chiavi risultano maggiori
elementi iniziali sono quelli o uguali a min e minori di
contenuti nella mappa map, la max. La mappa ritornata si
HashMap(Map<? extends K, ? SortedMap<K, V> subMap(K min, K
extends V> map) capacità iniziale della tabella di max) appoggia sulla mappa su cui
hash è basata sulla dimensione tale metodo è chiamato. La
di map Il fattore di carico è modifica delle associazioni
quello di default (0,75). della prima mappa si riflette
su quelle della seconda e
viceversa.
Interfaccia Implementazione Get containsKey Next TreeMap
Implementazione dell'interfaccia SortedMap<K, V> mediante un
SortedMap TreeMap<K, V> O(log n) O(log n) O(log n)
albero binario bilanciato. Essendo molto meno efficiente di una
<K, V>
5
 Marco Palena
HashMap<K, V> dovrebbe essere usato solo quando si abbia
effettivamente bisogno di mantenere l'ordinamento delle chiavi o
quando il metodo hashCode() per le chiavi non sia scritto in maniera iterazioni su una collezione di oggeti di tipo E. Tali metodi sono:
efficiente.
Get containsKey Next
O(log n) O(log n) O(log n)
Prevede i costruttori:
Costruttore Descrizione
Crea una nuova TreeMap
ordinata secondo l'ordinamento
naturale del tipo delle sue
TreeMap() chiavi. Tutte le chiavi aggiunte
devono implementare
Comparable ed essere
reciprocamente confrontabili.
Crea una nuova TreeMap
ordinata secondo l'ordinamento
naturale del tipo delle sue
chiavi e con associazioni
TreeMap(Map<? extends K, ?
extends V> map) iniziali quelle contenute in
map. Tutte chiavi in map e
aggiunte devono implementare
Comparable ed essere
reciprocamente confrontabili.
Crea una nuova TreeMap
TreeMap(Comparator<? super K>
comparator) ordinata secondo l'ordinamento Iterable
definito da comparator.
Crea una nuova TreeMap il cui metodi definiti dall'interfaccia Iterable<E>.
contenuto iniziale sarà lo stesso
TreeMap(SortedMap<K, V> map) di map, ordinato secondo lo
stesso ordinamento previsto da
quest'ultima.
Iterazione
Iterator<E>
Iterable<E>
ListIterator<E>
Prontuario di Programmazione a Oggetti: Java
Iterator
L'interfaccia Iterator<E> definisce i metodi necessari per eseguire
Metodo Descrizione
Restituisce true nel caso in
boolean hasNext() cui l'iterazione preveda
ulteriori elementi.
Restituisce l'elemento
successivo all'interno
dell'iterazione. Se non esiste
E next()
un elemento successivo
solleva
NoSuchElementException.
Rimuove dalla collezione
sottostante, l'elemento che è
stato fornito per ultimo
dall'iterazione. Può essere
chiamato solo una volta dopo
ogni next(), in caso contrario
void remove() solleva
IllegalStateExcleption.
Modifica la collezione
sottostante in maniera sicura
per l'iterazione, ogni altra
modifica è da considerarsi
non sicura.
L'implementazione degli oggetti iteratori delle collezioni è in
genere nascosta. L'accesso a tali oggetti avviene per mezzo dei
Metodo Descrizione
Restituisce un iteratore che
Iterator<E> iterator() permette di esaminare la
collezione corrente.
ListIterator
L'interfaccia ListIterator<E> estende Iterator<E> aggiungendone
metodi utilizzabili per manipolare, durante l'iterazione, un oggetto
di tipo List<E>. Un oggetto di tipo ListIterator<E> è ottenibile
6
Collezioni
mediante il metodo listIterator() dell'interfaccia List<E>. Aggiunge
ai metodi di Iterator() (che permettono di iterare in avanti su una
collezione) metodi che permettono l'iterazione all'indietro sulla lista.
Metodo Descrizione
Restituisce true nel caso in
boolean hasPrevious() cui l'iterazione all'indietro
preveda ulteriori elementi.
Restituisce l'elemento
precedente all'interno
dell'iterazione. Se non esiste
E previous()
un elemento precedente
solleva
NoSuchElementException.
Restituisce l'indice
dell'elemento restituito da
una successiva invocazione
int nextIndex() di next(). Se l'iteratore è
posizionato sull'ultimo
elemento della lista ritorna
size().
Restituisce l'indice
dell'elemento restituito da
una successiva invocazione
int previousIndex() di previous(). Se l'iteratore è
posizionato sul primo
elemento della lista ritorna
-1.
Ridefinisce il metodo
remove() di Iterator<E> in
void remove() modo che rimuova l'ultimo
valore restituito da next() o
da previous().
Sostituisce elem con l'ultimo
void set(E elem) elemento restituito da next()
o da previous().
void add(E elem) Inserisce nella lista l'oggetto
elem situandolo prima
dell'elemento che dovrebbe
essere restituito normalmente
come successivo, o alla fine
 Marco Palena
della lista nel caso in cui
hasNext() restituisca false.
Infine fa avanzare l'iteratore.
Comparazione
Comparable<E> Comparator<E>
Comparable
Interfaccia che definisce la relazione d'ordine naturale tra gli oggetti
delle classi che la implementano. Comparable<E> risiede nel
package java.lang. Definisce il metodo:
Metodo Descrizione
Restituisce un valore che è
minore, uguale o maggiore di
zero a seconda che l'oggetto
corrente sia minore, uguale o
int compareTo(E other)
maggiore rispetto all'oggetto
other. Se i due oggetti non
sono confrontabili solleva
ClassCastException.
Comparator
Interfaccia che definisce una relazione d'ordine arbitraria tra
determinati oggetti. Le implementazioni di tale interfaccia sono
oggetti comparatori Comparator<E> mediante le quali è possibile
definire ordinamenti alternativi sugli oggetti di tipo E.
Comparator<E> risiede nel package java.util. Definisce il metodo:
Metodo Descrizione
Restituisce un valore che è
minore, uguale o maggiore di
zero a seconda che l'oggetto
e1 sia minore, uguale o
int compare(E e1, E e2)
maggiore rispetto all'oggetto
e2. Se i due oggetti non sono
confrontabili solleva
ClassCastException.
Utility
Prontuario di Programmazione a Oggetti: Java
La classe Collections definisce numerosi metodi statici di utilità.
Metodi su collezioni ordinate
Metodo
<T extends Comparable<? super T>>
T min(Collection<? extends T> coll)
<T> T min(Collection<? extends T>
coll, Comparator<? super T> comp)
<T extends Comparable<? super T>>
T max(Collection<? extends T> coll)
<T> T max(Collection<? extends T>
coll, Comparator<? super T> comp)
Metodi su liste
Metodo
void reverse(List<?> list)
void shuffle(List<?> list)
void swap(List<?>, int i, int j)
<T extends Comparable<? super T>>
void sort(List<T> list)
Descrizione
Restituisce l'elemento di
valore più piccolo
all'interno della collezione
in base all'ordinamento
naturale.
Restituisce l'elemento di
valore più piccolo
all'interno della collezione
in base all'ordinamento
definito da comp.
Restituisce l'elemento di
valore più grande
all'interno della collezione
in base all'ordinamento
naturale.
Restituisce l'elemento di
valore più grande
all'interno della collezione
in base all'ordinamento
definito da comp.
Descrizione
Rovescia l'ordine degli
elementi presenti nella
lista.
Mescola a caso il
contenuto della lista.
Scambia gli elementi i-
esimo e j-esimo della lista
indicata.
Riordina list secondo
l'ordinamento naturale dei
<T> void sort(List<T> list,
Comparator<? super T> comp)
<T> int binarySearch(List<? extends
Comparable<? super T>> list, T key)
<T> int binarySearch(List<? extends
T> list, T key, Comparator<? super T>
comp)
Collezioni
suoi membri.
Riordina list secondo
l'ordinamento definito da
comp.
Esegue l'algoritmo di
ricerca binaria sulla lista
list per individuare
l'oggetto key restituendone
l'indice. La lista deve
essere ordinata secondo
l'ordinamento naturale. Se
key non è presente nella
lista restituisce un indice
negativo.
Esegue l'algoritmo di
ricerca binaria sulla lista
list per individuare
l'oggetto key restituendone
l'indice. La lista deve
essere ordinata secondo
l'ordinamento definito da
comp. Se key non è
presente nella lista
restituisce un indice
negativo.