Class RubricaTelefonica

java.lang.Object
  RubricaTelefonica

All Implemented Interfaces:

java.lang.Iterable<Contatto>

public class RubricaTelefonica
extends java.lang.Object
implements java.lang.Iterable<Contatto>

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:
  1. o è null e null è un elemento di coll;
  2. 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.

Constructor Summary

RubricaTelefonica()
Costruisce una rubrica telefonica vuota.

Method Summary

void	addContatto(Contatto cont) Se il contatto specificato dall'argomento non è nella rubrica che esegue il metodo lo aggiunge, altrimenti non compie alcuna operazione.
int	getNumeroContatti() Restituisce il numero complessivo di contatti nella rubrica che esegue il metodo.
java.util.Iterator<Contatto>	iterator() Restituisce un iteratore per i contatti della rubrica che esegue il metodo.
void	ordina() Ordina la rubrica che esegue il metodo.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

RubricaTelefonica

public RubricaTelefonica()

Costruisce una rubrica telefonica vuota.

Method Detail

addContatto

public void addContatto(Contatto cont)

Se il contatto specificato dall'argomento non è nella rubrica che esegue il metodo lo aggiunge, altrimenti non compie alcuna operazione.

getNumeroContatti

public int getNumeroContatti()

Restituisce il numero complessivo di contatti nella rubrica che esegue il metodo.

iterator

public java.util.Iterator<Contatto> iterator()

Restituisce un iteratore per i contatti della rubrica che esegue il metodo.

Specified by:

iterator in interface java.lang.Iterable<Contatto>

ordina

public void ordina()

Ordina la rubrica che esegue il metodo.