Ingegneria del software
Jody Marca – jody.marca@polimi.it
I Generics
I Generics rendono possibile definire tipi parametrici tramite classi ed interfacce che gestiscono tipi generici
Una classe generica è dichiarbile usando una variabile di tipo E.
public class GenericTest<E> { private E var;
public GenericTest(E var){ this.var = var;}
public E getVar() { return var; }
public void setVar(E var) { this.var = var;}
}
© 2015 – Jody Marca – Generics and collections
I Generics - Esempio
Proviamo ad invocare la classe GenericTest
public static void main(String[] args) {
String st = (new GenericTest<String>("aaa")).getVar();
System.out.println(st+ " - "+st.getClass());
Integer it = (new GenericTest<Integer>(100)).getVar();
System.out.println(it+ " - "+it.getClass());
}
Risultato esecuzione:
aaa - class java.lang.String 100 - class java.lang.Integer
Generics
Il tipo di dato che indicate va a sostituire la variabile di tipo utilizzata nella definizione dell’interfaccia o della classe generica (ArrayList<String> o ArrayList<MiaClasse>)
Non si possono utilizzare i tipi primitivi ma solo oggetti
ArrayList<double> // Sbagliato ArrayList<Double> // Giusto
© 2015 – Jody Marca – Generics and collections
Java Collections Frameworks
Rappresenta un’architettura unificata preposta all’uso e al trattamento di gruppi di oggetti.
Sono principalmente composte da:
Interfacce: tipi di dati astratti che rappresentano collezioni, come List, Queue, Set e Map
Implementazioni: classi basilari che implementano le interfacce fondamentali
Algoritmi: implementazioni di funzioni basilari come ordinamento e ricerca, applicabili a tutte le collezioni
Collections - gerarchia
© 2015 – Jody Marca – Generics and collections
Collections – Metodi dell’interfaccia
// Operationi di base int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(E element); // Opzionale
boolean remove(Object element); // Opzionale Iterator iterator();
// Operationi sull’insieme
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c); // Opzionale boolean removeAll(Collection<?> c); // Opzionale
boolean retainAll(Collection<?> c); // Opzionale void clear(); // Opzionale
Set
Set è una collezione che rappresenta un insieme di oggetti privo di elementi duplicati.
Le tre principali implementazioni sono:
HashSet TreeSet
LinkedHashSet
I set non mantengono alcun ordinamento, se questo fosse necessario si può utilizzare un SortedSet.
L’ordinamento può essere definito attraverso l’uso di un Comparator
© 2015 – Jody Marca – Generics and collections
Liste
List è una collezione che rappresenta una sequenza di oggetti nella quale sono ammessi i duplicati.
Le tre principali implementazioni sono:
ArrayList LinkedList Vector
Fornisce metodi aggiuntivi rispetto a Collection
Liste 2
// Accesso Posizionale E get(int index);
E set(int index, E element);
boolean add(E element);
void add(int index, E element);
E remove(int index);
boolean addAll(int index, Collection<? extends E> c);
// Ricerca
int indexOf(Object o);
int lastIndexOf(Object o);
// Iterazione
© 2015 – Jody Marca – Generics and collections
Queue
Queue è una collezione di oggetti pensata per contenere gli elementi prima di processarli;
l’implementazione principale è LinkedList.
Fornisce metodi aggiuntivi rispetto a Collection
Operazione Throws exception Returns special value
Insert add(e) offer(e)
Remove remove() poll()
Examine element() peek()
Map
Map è una collezione che permette di associare un valore ad una chiave. Non sono ammessi valori e chiavi duplicate. Sono ammessi valori nulli!
Le tre principali implementazioni sono:
HashMap TreeMap
LinkedHashMap
Fornisce metodi aggiuntivi rispetto a Collection
© 2015 – Jody Marca – Generics and collections
Map 2
// Operatori base
V put(K key, V value);
V get(Object key);
V remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
// Collection Views Set<K> keySet();
Collection<V> values();
Set<Map.Entry<K,V>> entrySet();
HashTable
Hashtable non è una collezione ma implementa l’interfaccia Map
La principale differenza tra la Hashtable e la Hashmap è che la Hashtable è sincronizzata e non ammette valori nulli.
Hashtable<String, Integer> numbers =
new Hashtable<String, Integer>();
© 2015 – Jody Marca – Generics and collections
Interface Iterator<E>
L’oggetto iterator permette di scandire e rimuovere oggetti da collezioni.
Fornisce i seguenti metodi:
boolean hasNext() E next();
void remove();
Iterator<String> iteratore = listaStringhe.iterator();
while(iteratore.hasNext()){
stringa = iteratore.next(); //Elemento successivo iteratore.remove(); //Rimuovi elemento corrente
}
Osservazione su Generics e Collections
E’ possibile vincolare il tipo generico ad essere un sottotipo di un tipo dato
public void metodo(Collection<? extends MiaSuperClasse> padre)
Il metodo mostrato può gestire una qualsiasi collezione i cui elementi estendono la classe MiaSuperClasse
