Sul pattern Iterator

Transcript

1 Sul pattern Iterator 1 Introduzione Capita spesso di aver a che fare con strutture dati complesse, come ad esempio, liste, code, ecc. È buona norma accedere a queste strutture senza esporre la loro organizzazione. Inoltre, è a volte necessario percorrere la struttura in modi diversi, senza per questo caricare l interfaccia della medesima con un numero eccessivo di metodi. Il pattern Iterator ha lo scopo di fornire un oggetto (o più oggetti) per percorrere la struttura in modo sequenziale. Un iterator corrisponde al concetto di cursore: il cursore punta a un elemento nella struttura e fornisce i metodi per percorrerla, esaminare l elemento corrente, ecc. Figura 1: Schema di un iteratore Nello schema di Figura 1 l iteratore ha un riferimento all aggregato che esso è in grado di percorrere; il significato dei metodi dell iteratore è sostanzialmente questo: first() inizializza l iteratore restituendo il primo elemento dell aggregato; getnext() restituisce l elemento corrente e fa avanzare il cursore 1 ; hasnext() dice se nell aggregato ci sono o meno ancora elementi, ma non fa avanzare il cursore. Il concetto di iteratore ci consente di disaccoppiare la struttura dal suo accesso. Un iteratore viene di norma istanziato passando l aggregato su cui deve operare. In Figura 1, il programma client tiene un riferimento all iteratore per accedere all aggregato. Dato un certo aggregato, è ovviamente possibile definire per esso differenti iteratori aventi il compito di implementare differenti tecniche di accesso. 2 Il polimorfismo Nel modello di Figura 1 il client vede un iteratore direttamente collegato all aggregato e quindi sa che di che tipo di aggregato si tratta. Il concetto di iteratore può essere generalizzato ricorrendo al polimorfismo, definendo un aggregato astratto dal quale si deriva un aggregato concreto, per i quale viene istanziato (dallo stesso aggregato concreto) il relativo iteratore, come schematizzato in Figura 2. Nello schema di Figura 2, l aggregato (concreto) deve passare se stesso al costruttore dell iteratore (in modo che esso sappia su quale specifico aggregato concreto sta lavorando). L aggregato restituisce il riferimento all iteratore appena creato al programma client. Mostriamo ora come lo schema di Figura 2 si traduce in classi Java. La classe Aggregato è astratta e definisce il metodo astratto createiterator() che restituisce un oggetto di tipo Iteratore. 1 Ad esempio: se getnext() viene eseguito subito dopo first(), restituisce il secondo elemento dell aggregato e posiziona il cursore sul terzo elemento. 1

2 Figura 2: Il pattern Iterator abstract class Aggregato { public abstract Iteratore createiterator(); \\ altro La classe AggregatoConcreto deve implementare il metodo appena menzionato. class AggregatoConcreto extends Aggregato { public Iteratore createiterator() { Iteratore i = new IteratoreConcreto(this); return i; \\ altro L iteratore prende la forma seguente. abstract class Iteratore { public abstract Elemento first(); public abstract Boolean hasnext(); public abstract Elemento getnext(); Mentre l iteratore concreto ha questa forma: class IteratoreConcreto extends Iteratore { private Aggregato a; public IteratoreConcreto(Aggregato a){ this.a= a; public Elemento first() { // public Elemento getnext() { // public Boolean hasnext() { // Il Client opera in questo modo: Istanzia un AggregatoConcreto (in modo polimorfico, dichiarandolo Aggregato). 2

3 Chiede all aggregato appena istanziato di creare l iteratore ottenendone il riferimento. Usa l iteratore per ispezionare l aggregato. Nel client: Aggregato a = new AggregatoConcreto(); Iteratore i = a.createiterator(); i.first().un_metodo(); i.getnext().un_metodo(); \\un metodo del primo elemento \\un metodo del secondo elemento 3 Estensioni In Figura 3 viene data una rappresentazione che mostra due (diversi) aggregati concreti manipolati dai rispettivi iteratori. Figura 3: Esempio. Interessante è il caso di un aggregato per il quale sono definiti più iteratori che, presumibilmente, percorrono l aggregato in modo diverso. In Figura 4, il metodo di creazione dell iteratore prevede un parametro in base al quale viene scelto quale genere di iteratore istanziare. In questo caso l aggregato concreto è una fabbrica che riporta un tipo di iteratore in base la parametro. In questo caso nel client seguirà lo schema sotto riportato. Il parametro del metodo createiterator() dice quale tipo di iteratore deve essere creato. Aggregato a = new AggregatoConcreto(); Iteratore i1 = a.createiterator(1); // tipo 1 Iteratore i2 = a.createiterator(2); // tipo 2 i1.first(); i1.getnext(); i2.first(); i2.getnext(); Una soluzione alternativa è prevedere distinti metodi di creazione. Definizione Il Pattern Iterator fornisce un modo di accedere sequenzialmente agli oggetti presenti in un aggregato, senza esporre la rappresentazione interna della struttura dell aggregato. 3

4 Figura 4: Più iteratori sulla stessa struttura. 4 Le Collections di Java Java, attraverso il package java.util dispone di una architettura unificata (detta Collections Framework) che permette di rappresentare e manipolare collezioni, indipendentemente dal dettaglio della loro rappresentazione. Il tutto è basato su un certo numero di interfacce e di classi (parametrizzate) tra cui alcune astratte. Ad esempio è definita l interfaccia List<E>, implementata da diverse classi, tra cui AbstractList, AbstractSequentialList, ArrayList, Stack e Vector (tutte parametriche). La classe di più alto livello del framework è AbstractCollection<E>, che discende direttamente dalla radice di tutta la gerarchia java, cioè da java.lang.object. Da AbstractCollection<E> discendono tutte altre collezioni. La classe AbstractCollection<E> implementa l interfaccia Iterable<T> e pertanto per essa è definito un iteratore per il tipo T. Più specificatamente l interfaccia Iterable<T> prevede il solo metodo iterator(), che restituisce un iteratore per il tipo T (cioè, restituisce un oggetto Iterator<T> 2 ). Ovviamente tutte le classi derivate da AbstractCollection<E> continuano ad implementare l interfaccia Iterable, dunque se si definisce per esse un iteratore, questo possederà i tre metodi dell interfaccia Iterator. Una ulteriore specializzazione di Iterator è ListIterator, che aggiunge altri metodi a quelli appena detti. 4.1 Esempio Nel caso del nostro modello che manipolava una struttura composta di solidi, è stata definita una classe astratta di nome Struttura, all interno della quale viene dichiarato l attributo solidi come AbstractCollection<Solido> 3 public abstract class Struttura { protected AbstractCollection<Solido> solidi; void addsolido(solido solidi.add(s); s){ double getvolume() { double vol = 0; Iterator<Solido> it = solidi.iterator(); 2 Iterator<T> è in realtà a sua volta un interfaccia con questi metodi hasnext, next e remove. Pertanto viene effettivamente restituito un oggetto che presenta questa interfaccia. 3 Solido è la classe astratta che definisce un solido. 4

5 while (it.hasnext()){ vol = vol + it.next().getvolume(); return vol; \\ ecc. Come si vede, è possibile usare il metodo add() di AbstractCollection<Solido> per aggiungere solidi alla struttura. Più interessante è l uso dell iteratore. L iteratore it definito per il tipo Solido si ottiene attraverso il metodo iterator() (dell interfaccia Iterable), implementato da AbstractCollection<Solido> (e perciò da tutte le classi nella gerarchia). Il metodo riporta un iteratore posizionato sul primo elemento della collezione. Nel nostro esempio la classe astratta AbstractCollection<Solido> veniva istanziata nelle due classi concrete Vector e ArrayList. Non c è stato bisogno di definire per queste l iteratore in quanto ereditato dalla classe padre. Il nostro esempio ci ha dato l opportunità di introdurre uno dei design pattern e di mostrare come java fornisce il concetto di iteratore nel contesto di framework molto utile e facilmente impiegabile ogni volta che si deve trattare collezioni di oggetti. 5 Una lista A titolo di esercizio costruiamo una lista e il relativo iteratore. Anzitutto stabiliamo che il generico elemento della lista costruito con tre componenti: f: forward (fa le veci del puntatore in avanti, al prossimo Elem in lista) e: generico elemento da mettere in lista (dichiarato come Object) b: backward (fa le veci del puntatore indietro, al precdente Elem in lista) package lista; class Elem { Elem f; Object e; Elem b; //puntatore in avanti //Elemento Generico informazione //puntatore indietro Elem(Object o){ f= null; e = o; b= null; Elem getf(){ return f; //costruttore di un Elem di Lista La lista viene costruita come sotto. Si noti che quando la lista viene costruita c è un elemento dummy che fa da radice della lista. Quando nella lista ci sono elementi esso punta con f al primo, con b all ultimo. package lista; public class Lista { protected Elem x; public Lista(){ x = new Elem(null); //Radice della lista //Per x le componenti f e b sono usate in modo (semi) degenere // la componente f punta al primo in lista 5

6 public void add(object o){ Elem e = new Elem(o); if (x.f == null){ x.f = e; x.b = e; e.b = x; else{ e.b = x.b; x.b.f = e; x.b = e; // la componente b punta all ultimo in lista //costruzione elemento //x punta a e //e è anche la fine //e punta indietro a x //e punta indietro all ultimo già in lista //il precedente ultimo punta in avanti a e //e è alla fine della lista public Object remove(){ //rimuove sempre l ultimo (se c è) if (x.b == null) return null; //se vuota Elem e = x.b; //ultimo elemento x.b = e.b; //puntatore al nuovo ultimo x.b.f = null; //fine lista return e.e; public Iteratore createiterator(){ return new Iteratore(this); //crea il suo iteratore L iteratore segue qui sotto. Notare che il cursore i punta sempre all ultimo elemento estratto, in modo che i.f è il prossimo elemento da estrarre. Quando il cursore viene creato, esso va a coincidere con x (il dummy di partenza). Quindi i.f punta al primo da estrarre package lista; public class Iteratore { private Elem i, copiax; public Iteratore(Lista l){ i = l.x; //cursore parte dall inizio (che è in x) copiax = l.x; //copia di x (per il first) public boolean hasnext(){ if (i.f == null) return false; else return true; public Object getnext(){ Elem e = i.f; //dove punta il cursore if(e == null)return null; // se è in fondo i = e; //avanti col corsore return e.e; //la componente informativa public Object first(){ i = copiax; //punta al dummy if(i.f == null) return null; //in lista non c è nulla 6

7 else { Elem e = i.f; i = e; return e.e; //prende il primo //avanti col cursore 7