import java.util.*; /** * Una RubricaTelefonica è una collezione di contatti. *
* Una rubrica non può contenere contatti uguali * (l'uguaglianza fra contatti è quella definita nella classe Contatto). *

La collezione di contatti è rappresentata dal campo privato *elencoContatti che ha tipo List<Contatto>. *
* L'interfaccia List<E> *(da non confondere con la classe concreta List) * estende l'interfaccia Collection<E>. * Come spiegato sotto, le API Java permettono di ordinare *collezioni di tipo List<E>. *

* NOTA * RubricaTelefonica non è *sottotipo di List<Contatto>, *in quanto RubricaTelefonica non implementa * l'interfaccia List<Contatto>. * * * *

*Poiché nella rubrica non sono ammessi duplicati, * prima di aggiungere un contatto cont occore controllare * che cont non sia già nella rubrica. *
* Si può usare il metodo *

 *  boolean contains(Object o)
 *

*definito nell'interfaccia Collection<E> (e quindi ereditato * da List<E>). *
* La definizione del metodo contains nella documentazione è la seguente: *

* * * * *

Returns true if this collection contains the specified element. *
* More formally, returns true if and only if this collection * contains at least one element e such that * (o==null ? e==null : o.equals(e)). *

*
* Quindi, se coll è un oggetto di tipo * Collection<E> e o è un oggetto * di tipo E, la chiamata *

 
 *    coll.contains(o)
 *

* restituisce true se e solo se vale una delle seguenti due condizioni: *

* o è null * e null è un elemento di coll; *
* o è diverso da null * e coll contiene almeno un elemento e * tale che o.equals(e) restituisce true. *

*La classe RubricaTelefonica implementa l'interfaccia *Iterable<Contatto>. * Deve quindi definire un metodo *
```
 *   public Iterator<Contatto> iterator()
 *
```
*che restituisce un iteratore per i contatti nella rubrica. *
* Sull'iteratore restituito dal metodo iterator * è possibile eseguire il ciclo for-each. *

* NOTA *Quando si sta attraversando una collezione con un iteratore, la collezione non * può essere modificata. * Ad esempio, il codice *
```
 * Iterator<Contatto>  it = elencoContatti.iterator(); // definisce un iteratore per elencoContatti
 * // ciclo che cancella tutti i contatti in  elencoContatti
 * while(it.hasNext()){     // termina quando in it non ci sono piu' elementi 
 *       Contatto cont = it.next();       // prossimo elemento nell'iteratore
 *       elencoContatti.remove(cont);     // togli da  elencoContatti il contatto cont
 *  }
 * 
*
```
* è compilato, ma solleva in esecuzione l'eccezione *
```
*   java.util.ConcurrentModificationException
*
```
* in quanto, finché il ciclo che utilizza l'iteratore it non è terminato, * la collezione elencoContatti non può essere modificata. *
*Occorre invece usare il metodo remove dell'interfaccia Iterator<E>: *
```
 * ...
 * while(it.hasNext()){  
 *      Contatto cont = it.next(); 
 *      it.remove();    // elimina dall'iteratore l'elemento corrente 
 *      numeroContatti--;
 *  }
*  // gli elementi eliminati dall'iteratore sono eliminati anche da elencoContatti
*
```
*
* Si ricordi che il ciclo for-each utilizza implicitamente *un iteratore, quindi una collezione attraversata con tale ciclo non * può essere modificata. *

*Poiché la classe Contatto implementa l'interfaccia * Comparable<Contatto>, è possibile ordinare i * contatti usando il metodo statico *
```
 *    public static <T extends Comparable<? super T>> void sort(List<T> list)
 *
```
* della classe Collections (da non confondere con l'interfaccia * Collection<E>). *
* La definizione del metodo sort richiede che: *
- * L'argomento deve essere un oggetto che implementa * l'interfaccia List<T>. *
- * Il tipo T deve essere un sottotipo di * Comparable<S>, dove S * è un supertipo di T. *
  * Questo serve per garantire che sugli oggetti della lista argomento sia definito il * metodo compareTo (usato dal metodo sort * per ordinare gli elementi della lista). *
*Nel nostro caso T è la classe Contatto ed entrambe * le condizioni sono verificate *in quanto Contatto implementa l'interfaccia Comparable<Contatto>. * L'ordinamento viene fatto in base alla definizione del metodo compareTo * della classe Contatto. *

*/ public class RubricaTelefonica implements Iterable{ // CAMPI private List elencoContatti; // collezione dei contatti nella rubrica private int numeroContatti; // numero dei contatti nella rubrica // COSTRUTTORI /** Costruisce una rubrica telefonica vuota. */ public RubricaTelefonica() { // occorre inizializzare i campi della classe } /** * Se il contatto specificato dall'argomento non è nella rubrica * che esegue il metodo lo aggiunge, * altrimenti non compie alcuna operazione. * */ /* per controllare se cont e' nella rubrica, usare il metodo contains definito nell'interfaccia List Ricordarsi di aggiornare numeroContatti */ public void addContatto(Contatto cont) { } /** * Restituisce il numero complessivo di contatti nella rubrica che esegue il metodo. * */ public int getNumeroContatti(){ return numeroContatti; } /** * Restituisce un iteratore per i contatti della rubrica che esegue il metodo. * */ // implementa il metodo iterator richiesto dall'interfaccia Iterable // e' sufficiente chiamare il metodo iterator definito in Collcection public Iterator iterator() { return null; } /** * Ordina la rubrica che esegue il metodo. * */ // usare il metodo statico sort della classe Collections public void ordina(){ } }// end class