1 Astrazione sul controllo: gli iteratori

2 Perché vogliamo iterarare “in modo astratto” 4 problema: iterare su tipi di dato arbitrari  esempio: procedura stand-alone per calcolare la somma di tutti gli elementi di un IntSet public static int setSum (IntSet s) throws NullPointerException // EFFECTS: se s è null solleva // NullPointerException altrimenti // ritorna la somma degli elementi di s

3 Problema 4 Non vediamo la rappresentazione (p.e. quella realizzata dal vettore els) 4 Dobbiamo usare i metodi pubblici forniti dalla classe IntSet 4 Unico modo per accedere agli elementi: choose

4 L’insieme di interi 1 public class IntSet { // costruttore public IntSet () // EFFECTS: inizializza this a vuoto // metodi public void insert (int x) // MODIFIES: this // EFFECTS: aggiunge x a this public void remove (int x) // MODIFIES: this // EFFECTS: toglie x da this public boolean isIn (int x) //EFFECTS: se x appartiene a this ritorna // true, altrimenti false...}

5 L’insieme di interi 2 public class IntSet {... // metodi... public int size () // EFFECTS: ritorna la cardinalità di this public int choose () throws EmptyException // EFFECTS: se this è vuoto, solleva // EmptyException, altrimenti ritorna un // elemento qualunque contenuto in this }

6 Una soluzione 4 Prendiamo un elemento a caso con il metodo choose 4 Lo rimuoviamo 4 Ripetiamo fino a svuotare l’insieme 4 La procedura non deve modificare l’insieme (non e’ riportato in MODIFIES) 4 Quindi ci vuole una struttura di supporto per memorizzare gli elementi

7 Soluzione insoddisfacente 1 public static int setSum (IntSet s) throws NullPointerException { // EFFECTS: se s è null solleva // NullPointerException altrimenti // ritorna la somma degli elementi di s int[ ] a = new int [s.size( )]; int sum = 0; for (int i = 0; i < a.length; i++) {a[i] = s.choose( ); sum = sum + a[i]; s.remove(a[i]); } // risistema s for (int i = 0; i < a.length; i++) s.insert(a[i]); return sum;}  ad ogni iterazione vengono chiamate due operazioni ( choose e remove ) 4 gli elementi rimossi li mettiamo in un array, poi li riinseriamo

8 Problemi analoghi 4 Compitino di MP (procedura statica su pila) 4 Compitino di LIP (procedura statica su coda) 4 Non esisteva un modo per visitare gli elementi memorizzati nella struttura dati

9 Soluzione Sbagliata 4 Un modo di risolvere il problema (accedere alla rappresentazione) 4 Per esempio, in IntSet accedere agli elementi memorizzati nel vettore els (mettendo els pubblico) 4 Da evitare: rompe l’astrazione rendendo dipendenti gli altri moduli dall’implementazione

10 Soluzione insoddisfacente 2 4 Il tipo di dato astratto non e’ progettato bene (metodi pubblici forniti sono limitati….)  potremmo aggiungere setSum come metodo d’istanza della classe IntSet –in modo più efficiente accedendo la rappresentazione –non è direttamente collegata al concetto di IntSet –quante altre operazioni simili dovremmo mettere in IntSet ? trovare il massimo elemento Meglio sarebbe modifacre la specifica mettendo delle operazioni che siano un po’piu’ generali

11 Cosa non fare  dotiamo IntSet di una operazione che ritorna la rappresentazione (metodo d’istanza) public Vector members () // EFFECTS: restituisce il Vector contenente gli // elementi di this 4 Soluzione assolutamente sbagliata: rende accessibile la rappresentazione (rompe l’astrazione) 4 Il codice della procedura dipende dalla rappresentazione 4 Non possiamo piu’ garantire le proprieta’ di IntSet (la rappresentazione puo’ essere modificata dall’esterno)

12 Soluzione leggermente diversa public int [ ] members () // EFFECTS: restituisce un array contenente gli // elementi di this, ciascuno esattamente una volta, // in un ordine arbitrario public static int setSum (IntSet s) { int[ ] a = s.members(); int sum = 0; for (int i = 0; i < a.length; i++) sum = sum + a[i]; return sum;} 4 inefficiente –due strutture dati –non sempre vogliamo generare tutti gli elementi della collezione massimo elemento

13 Di cosa abbiamo bisogno? 4 un meccanismo generale di iterazione, che permette di iterare sugli elementi di IntSet –facile da usare –efficiente –che preservi l’astrazione (ovvero che non riveli a chi lo usa il modo in cui l’insieme e’ implementato)

14 Vorremmo un generatore 4 un generatore g produce in modo incrementale (uno alla volta) tutti gli elementi i della collezione corrispondente all’oggetto 4 Utilizzando un generatore e’ possibile realizzare l’iterazione astratta: per ogni i prodotto da g esegui a su i 4 l’azione a da compiere sugli elementi è separata dalla generazione degli elementi stessi

15 Generatori in Java 4 i generatori sono oggetti di particolari classi (tipi)  Sono sottotipi di una Interfaccia Iterator –il tipo Iterator è definito dalla seguente interfaccia Java ( java.utilpackage )

16 Cos’e’ una Interfaccia 4 Una Interfaccia e’ un particolare tipo di classe 4 Contiene solo specifica e non implementazione 4 Serve per definire implementazioni multiple di un tipo o per definire operazioni comuni a vari tipi

17 Interfaccia Iterator (versione semplificata) public interface Iterator { public boolean hasNext ( ); // EFFECTS: restituisce true se ci sono altri // elementi altrimenti false public Object next throws NoSuchElementException; // MODIFIES: this // EFFECTS: se ci sono altri elementi da generare dà il // successivo e modifica lo stato di this, altrimenti // solleva NoSuchElementException (unchecked)}

18 Sottotipi di una interfaccia 4 Si definiscono usando la parola chiave implements (al posto di extends) 4 Ereditano i metodi dall’interfaccia e li implementano 4 In questo modo si puo’ definire una famiglia di sottotipi che hanno un’insieme di operazioni comuni

19 Generatori –un generatore su una data collezione si definisce implementando l’interfaccia Iterator –un generatore si crea, creando un oggetto di quel tipo –tutti i generatori hanno quindi i metodi next ed hasnext che si comportano nello stesso modo (come dichiarato nella superclasse)

20 Cosa vedremo? 4 Come si usa un generatore (dal punto di vista dei moduli che lo usano) per realizzare l’iterazione astratta su un tipo di dato 4 Come si implementa l’interfaccia Iterator

21 Iterazione astratta 4 Per utilizzare generatori per iterare in modo astratto su una collezione, bisogna aggiungere un metodo che ritorna un generatore nella specifica 4 Metodi che ritornano un generatore, spesso chiamati iteratori –da non confondere con il tipo Iterator che restituiscono 4 possono essere anche procedure stand alone –come primesLT100

22 Specifica di un iteratore per IntSet public class IntSet { // come prima più public Iterator elements () // EFFECTS: ritorna un generatore che produrrà tutti // gli elementi di this (come Integers) ciascuno una // sola volta, in ordine arbitrario // REQUIRES: this non deve essere modificato // finché il generatore è in uso } 4 la clausola REQUIRES impone condizioni sul codice che utilizza il generatore –per questo è messa alla fine –tipica degli iteratori su tipi di dato modificabili

23 Specifica di un iteratore per Poly public class Poly { // come prima più public Iterator terms () // EFFECTS: ritorna un generatore che produrrà gli // esponenti dei termini diversi da 0 in this (come // Integers) fino al grado del polinomio, in ordine // crescente }

24 Specifica di un iteratore stand-alone 1  il metodo primesLT100 public class Num { // come prima più public static Iterator primesLT100 () // EFFECTS: restituisce un generatore, // che genera incrementalmente tutti i // numeri primi (Integer) minori di 100

25 Specifica di un iteratore stand alone public class Num { // come prima più public static Iterator allPrimes () // EFFECTS: ritorna un generatore che produrrà tutti // i numeri primi (come Integers) ciascuno una // sola volta, in ordine arbitrario } 4 il limite al numero di iterazioni deve essere imposto dall’esterno –il generatore può produrre infiniti elementi

26 Come si usano?  Al solito il metodo iteratore ed il generatore si usa guardando la specifica public static Iterator primesLT100 () // EFFECTS: restituisce un generatore, // che genera incrementalmente tutti i // numeri primi (Integer) minori di 100

27 Come si usano? 4 può essere utilizzato per realizzare un’iterazione astratta: per ogni i prodotto da g esegui a su I // ciclo controllato da hasnext Iterator g = Num.primesLT100 (); while (g.hasNext()) {int i = ((Integer) g.next( )).intValue( ); // esegui a su i }

28 Alternativa // ciclo controllato da exception Iterator g = Num.primesLT100(); try {while (true) {int i = ((Integer) g.next()).intValue(); // esegue a su i } catch (NoSuchElementException e) { };

29 // EFFECTS: stampa tutti i numeri primi minori o uguali a m // su System. Out Iterator g =Num.allPrimes(); while (true) { Integer p =(Integer) g.next(); if (p.intValue() > m) return; // forza la terminazione System.out.println("The next prime is: " + p.toString()); } Terminazione dall’esterno

30 IntSet public Iterator elements () // EFFECTS: ritorna un generatore che produrrà tutti // gli elementi di this (come Integers) ciascuno una // sola volta, in ordine arbitrario // REQUIRES: this non deve essere modificato // finché il generatore è in uso } Lo possiamo usare per realizzare: public static int setSum (IntSet s) throws NullPointerException // EFFECTS: se s è null solleva // NullPointerException altrimenti // ritorna la somma degli elementi di s

31 public static int setSum (IntSet s) throws NullPointerException { Iterator g= s.elements(); int sum = 0; try{while(true) {sum=sum +(Integer) g.next().intvalue();} } catch (NoSuchElementException e) {}} 4 Scritta guardando solo la specifica di IntSet 4 Realizza l’iterazione astratta (indipendente dalla rappresentazione) usando il generatore Procedura stand-alone

32 Iteratori 4 Abbiamo visto la specifica e l’uso dei metodi che ritornano un generatore (sottotipo di Iterator) 4 Questi metodi li abbiamo chiamati iteratori 4 Come e dove si definiscono generatori?

33 Implementazione degli iteratori e dei generatori  i generatori sono oggetti che hanno come tipo un sottotipo di Iterator –istanze di una classe  che “implementa” l’interfaccia Iterator  un iteratore  è un metodo (stand alone o associato ad un tipo astratto) che ritorna il generatore istanza di   Vogliamo che  acceda alla rappresentazione (deve iterare) senza renderla visibile

34 Esempio 4 Il generatore di IntSet deve produrre tutti gli elementi dell’insieme 4 Deve necessariamente poter accedere alla rappresentazione, ovvero al vettore els 4 La classe che definisce il generatore deve essere interna ad IntSet (non visibile da fuori)

35 Quindi  Il generatore  deve avere una visibilità limitata al package che contiene l’iteratore  –oppure può essere contenuta nella classe che contiene  come inner class privata  in questo modo i generatori sono visti dall’esterno come oggetti di tipo Iterator –perché il sottotipo  non è visibile

36 Classi nidificate  una classe  dichiarata all’interno di una classe  può essere –static (di proprietà della classe  ) –di istanza (di proprietà degli oggetti istanze di  )  se  è static come sempre non può accedere direttamente le variabili di istanza ed i metodi di istanza di  –le classi che definiscono i generatori si possono quasi sempre definire come inner classes statiche –prendono gli oggetti come parametro

37 Classi nidificate: semantica  la presenza di classi nidificate richiede la presenza di un ambiente di classi –all’interno delle descrizioni di classi –all’interno degli oggetti (per classi interne non static) –vanno modificate di conseguenza anche tutte le regole che accedono i nomi

38 public Iterator elements () { // EFFECTS: ritorna un generatore che produrrà tutti // gli elementi di this (come Integers) ciascuno una // sola volta, in ordine arbitrario // REQUIRES: this non deve essere modificato // finché il generatore è in uso return new IntSetGen(this);} Intset: iteratore public class IntSet { private Vector els; 4 Ritorna un oggetto di tipo IntSetGen, sottotipo di Iterator, a cui passa l’oggetto corrente 4 Il tipo IntSetGen e’ definito come inner class privata di IntSet, non e’ visibile da fuori (setsum scritta guardando solo la specifica)

39 private static class IntSetGen implements Iterator { private IntSet s; // l’insieme su cui si itera private int next; // prossimo indice del vettore da considerare 4 Manca l’OVERVIEW: il generatore e’ descritto nel corrispondente Iteratore (elements) Le variabili d’istanza mantengono le informazioni per iterare, l’insieme e l’indice del vettore a cui siamo arrivati 4 Nota che la classe e’ interna ad IntSet, ha visione delle variabili private di IntSet (in particolare del Vector) Intset:generatore 1

40 private IntSet s; // l’insieme su cui si itera private int next; // prossimo indice del vettore da considerare IntSetGen (IntSet it) { // REQUIRES: it != null s = it; next=0; } 4 Costruttore procedura parziale, usata solo all’interno della classe 4 Prende come parametro l’IntSet su cui operare (vedi elements()) Intset:generatore 1

41 public boolean hasNext () {if (next>= s.els.size()) {return false;} else {return true;} } public Object next () throws NoSuchElementException { if (next >= s.els.size()) { throw new NoSuchElementException(”IntSet.elements"); } return s.els.get(next); next=next+1;} 4 La specifica dei metodi e’ quella descritta nell’interfaccia (e’ sempre la stessa) Intset:generatore 2

42 Implementazione degli iteratori 1 public class Poly { private int[ ] termini; private int deg; public Iterator terms () {return new PolyGen(this); } // EFFECTS: ritorna un generatore che produrrà gli // esponenti dei termini diversi da 0 in this (come // Integers) fino al grado del polinomio, in ordine crescente private static class PolyGen implements Iterator { // inner class (classe annidata) private Poly p; // il Poly su cui si itera private int n; // il prossimo termine da considerare PolyGen (Poly it) { // REQUIRES: it != null p = it; if (p.termini[0] == 0) n = 1; else n = 0; } public boolean hasNext () {return n <= p.deg; } public Object next () throws NoSuchElementException { for (int e = n; e <= p.deg; e++) if (p.termini[e] != 0){n = e + 1; return new Integer(e); } throw new NoSuchElementException("Poly.terms"); } } }

43 Alternativa, classe d’istanza public Iterator terms () {return new PolyGen(); } // EFFECTS: ritorna un generatore che produrrà gli // esponenti dei termini diversi da 0 in this (come // Integers) fino al grado del polinomio, in ordine crescente private class PolyGen implements Iterator { // inner class (classe annidata) private int n; // il prossimo termine da considerare PolyGen () { // REQUIRES: it != null if (termini[0] == 0) n = 1; else n = 0; } public boolean hasNext () {return n <= deg; } public Object next () throws NoSuchElementException { for (int e = n; e <= deg; e++) if (termini[e] != 0) {n = e + 1; return new Integer(e); } throw new NoSuchElementException("Poly.terms"); } } } 4 Vede direttamente la rappresentazione (termini, deg)

44 Implementazione degli iteratori 3 public class Num { public static Iterator allPrimes (){return new PrimesGen();} // EFFECTS: ritorna un generatore che produrrà tutti // i numeri primi (come Integers) ciascuno una // sola volta, in ordine arbitrario private static class PrimeGen implements Iterator { // inner class (classe annidata) private Vector ps; // primi già dati private int p; // prossimo candidato alla generazione PrimesGen () {p = 2; ps = new Vector(); } public boolean hasNext () {return true } public Object next () { if (p == 2) { p = 3; return new Integer(2);} for (int n = p; true; n = n + 2) for (int i = 0; i < ps.size(); i++){ int e1 = ((Integer) ps.get(i)).intValue(); if (n%e1 == 0) break; // non è primo if (e1*e1 > n) {ps.add(new Integer(n); p = n + 2; return new Integer(n);}}} }}

45 Classi nidificate e generatori  le classi i cui oggetti sono generatori definiscono comunque dei tipi astratti –sottotipi di Iterator  in quanto tali devono essere dotati di –una funzione di astrazione –un invariante di rappresentazione 4 Necessarie per ragionare sulla loro correttezza

46 Funzione di astrazione per i generatori  dobbiamo sapere cosa sono gli stati astratti 4 per tutti i generatori, lo stato astratto è –la sequenza di elementi che devono ancora essere generati –la funzione di astrazione mappa la rappresentazione su tale sequenza

47 Funzione di Astrazione: IntSetGen private static class IntSetGen implements Iterator { private IntSet s; // l’insieme su cui si itera private int next; // prossimo indice del vettore da considerare  (c) = [] se c.next>=c.s.els.size() oppure   (c) =[x_i, x_i+1,...,x_n] tale che  c.next= i ed n=c.s.els.size()-1  e per ogni i <= j <=n  xj_ = c.els.get(j) notare che si usano le rep sia di IntSet che di IntSetGen

48 Invariante di rappresentazione I (c) = c.s != null e (0 <= c.next <= c.s.els.size()) 4 Il next varia tra 0 e la lunghezza del vettore

49 Correttezza dell’iteratore 4 Facciamo vedere che l’invariante di IntSetGen vale 4 Costruttore 4 Metodi per induzione sui dati

50 private static class IntSetGen implements Iterator { private IntSet s; // l’insieme su cui si itera private int next; // prossimo indice del vettore da considerare IntSetGen (IntSet it) { // REQUIRES: it != null s = it; next=0; } public boolean hasNext () {if (next > = s.els.size()) {return false;} else {return true;}} 4 I(c) = c.s != null e (0 <= c.next <= c.s.els.size()) Invariante

51 private static class IntSetGen implements Iterator { private IntSet s; // l’insieme su cui si itera private int next; // prossimo indice del vettore da considerare public Object next () throws NoSuchElementException { if (next >= s.els.size()) { throw new NoSuchElementException(”IntSet.elements"); } return s.els.get(next); next=next+1;} 4 I(c) = c.s != null e (0 <= c.next <= c.s.els.size()) Vale: se c.next era = c.s.els.size() allora ha sollevato l’eccezione Invariante

52 Correttezza del generatore 4 Valgono le invarianti di Intset e di IntSetGen 4 E’ facile convincersi che i metodi next e hasnext() soddisfano la specifica

53 Correttezza dell’iteratore 4 il generatore soddisfa anche la specifica (quella richiesta in elements) // EFFECTS: ritorna un generatore che produrrà tutti // gli elementi di this (come Integers) ciascuno una // sola volta, in ordine arbitrario 4 Il generatore ritorna gli elementi del vettore che rappresenta l’insieme 4 E’ corretto perche’: (1) non ci sono occorrenze multiple nel vettore; (2) gli elementi del vettore sono Integer 4 Queste proprieta’ sono garantite dall’invariante di IntSet

54 Conclusioni sugli iteratori 4 in molti tipi di dato astratti (collezioni) gli iteratori sono un componente essenziale –supportano l’astrazione via specifica –portano a programmi efficienti in tempo e spazio –sono facili da usare –non distruggono la collezione –ce ne possono essere più d’uno 4 se il tipo di dato astratto è modificabile ci dovrebbe sempre essere il vincolo sulla non modificabilità del dato durante l’uso dell’iteratore –altrimenti è molto difficile specificarne il comportamento previsto –in alcuni casi può essere utile combinare generazioni e modifiche