codice:
import java.util.*;
public class Involucro2{
/** OVERVIEW: Involucro rappresenta una collezione dinamica di stringhe del tipo <s1, s2, s3,...., sn> tali che
s_i è completamente contenuta in s_(i+1).
V = {{s1,s2,s3,...,sn>: Per ogni i s_i è una stringa ed s_i è interamente contenuto in s_(i+1)}}
O = inserisci: Se l'oggetto che si vuole inserire è coerente con la rappresentazione della collezione
(è una stringa) e con lo stato attuale della collezione (i valori già presenti nella
collezione), allora lo inserisce nella collezione modificandola
fondi: Date collezioni S e T se s_n è interamente contenuto in t_1 allora fonde le due collezioni nel
seguente modo: S = <s1,s2,s3,...,sn> T = {t1,t2,t3,...,tn} --> {s1,s2,s3,...,sn,t1,t2,t3,..,tn}
get(i): Accede in maniera posizionale all'i-esimo elemento della collezione */
Vector collStr; // Rappresenta la collezione di stringhe
/** FUNZIONE DI ASTRAZIONE: F_a(): STATO CONCRETO ----> STATO ASTRATTO
F_a([a, ab, abc, abcd]) ------> {<a, ab, abc, abcd>}
ma anche: F_a([a, b(a), (ba)f, z(baf), (zbaf)e]) ---> {a, ba, baf, zbaf, zbafe}
INVARIANTE DI RAPPRESENTAZIONE: è un predicato I: C ---> boolean che è vero per gli stati concreti che sono
rappresentazioni leggittime di uno stato astratto:
I(collStr): collStr != NULL (il Vector deve essere sempre diverso da NULL)
Per ogni i: v.get(i) deve essere incluso in v.get(i+1) (la i-esima stringa deve
sempre essere interamente contenuta nella (i+1)-esima stringa della collezione */
/** COSTRUTTORE:
EFFECTS: Crea un nuovo oggetto di tipo Involucro che rappresenta la collezione vuota
@param: void:
@return: Il riferimento ad un oggetto di tipo Involucro
Il costruttore soddisfa l'invariante di rappresentazione in quanto: 1) Viene assegnata alla variabile di istanza
collStr il riferimento ad un nuovo Vector quindi no è mai null. 2) Il costruttore crea una collezione vuota che
rappresenta la stringa vuota contenuta in ogni stringa, quindi qualsiasi sia il primo elemento va bene */
public Involucro2(){
collStr = new Vector(); // Crea la collezione vuota assegnando a collStr il riferimento ad un nuovo Vector vuoto
}
/** Metodo inserisci()
EFFECTS: Se il parametro può essere inserito nella collezione (se contiene completamente l'ultima stringa della
collezione, allora viene inserito nella collezione rappresentata dall'oggetto ricevente, altrimenti viene
sollevata una StringaNonValidaException
MODIFIES: this
@param: Un oggetto di tipo String
Il metodo inserisci() soddisfa l'invariante di rappresentazione in quanto se la collezione è vuota permette
l'inserimento di una stringa qualsiasi, se invece nella collezione è già presente qualcosa prima di inserire il
parametro controlla che il parametro contiene completamente l'ultima stringa presente nella collezione. Se ciò è
verificato la inserisce, altrimenti no e la collezione rimane sempre coerente con la sua definizione */
public void inserisci(String str){
int dimensione = collStr.size() ; // Contiene la dimensione del Vector collStr
String ultima = (String)collStr.elementAt(dimensione);
if(dimensione == 0) // Se la collezione è vuota
collStr.addElement(str); // Aggiungi la stringa parametro in prima posizione
else{ // Altrimenti, se nella collezione ci sono già degli elementi
if(str.contains(ultima)) // Se il parametro contiene l'ultima stringa della collezione
collStr.addElement(str); // Aggiungi la stringa parametro in prima posizione
else throw new StringaNonValidaException(); // altrimenti solleva un'eccezione
}
}
/** Metodo fondi():
EFFECTS: Se possibile fonde la collezione ricevente con quella referenziata dal parametro. Tale fusione è possibile
se e solo se l'ultimo elemento della collezione ricevente è totalmente contenuto nel primo elemento della
collezione referenziata dal parametro, altrimenti solleva una CollezioneParametroNonValidaExcepion
Eventualmente la dusione fosse possiebileil metodo crea una nuova collezione che contiene la fusione delle
due collezioni iniziali.
@param: Il riferimento ad un oggetto Involucro
@return: Il riferimento ad un nuovo oggetto Involucro
Il metodo rispetta l'invariante di rappresentazione in quanto ne l'oggetto ricevente, ne il parametro possono essere
null e poichè l'eventuale nuova collezione rispetta la proprietà che Per ogni i, l'i-esima stringa è sempre
contenuta nella (i+1)-esima stringa */
public Involucro2 fondi(Involucro2 coll){
Involucro2 fusione; // Conterrà l'eventuale fusione delle due collezioni
int dimensioneRicevente = collStr.size(); // Contiene la dimensione della collezione del ricevente
int dimensioneParametro = coll.collStr.size(); // Contiene la dimensione della collezione del parametro
int cont;
// Contiene l'ultima stringa della collezione ricevente
String ultimoElemRicevente = (String) collStr.elementAt(dimensioneRicevente);
// Contiene la prima stringa della collezione referenziata dal parametro
String primoElemPar = (String) coll.collStr.elementAt(0);
/* Se la prima stringa della collezione referenziata dal parametro contiene l'ultima stringa della collezione
dell'oggetto ricevente */
if(primoElemPar.contains(ultimoElemRicevente)){
fusione = new Involucro2(); // Costruisci un nuovo oggetto Involucro che conterrà la fusione
// Copia in ordine tutte le stringhe della prima collezione (oggetto ricevente) nell'oggetto fusione
for(cont=0; cont<=dimensioneRicevente; cont++){
fusione.collStr.addElement((String) collStr.elementAt(cont));
}
// Poi copia in ordine tutte le stringhe della collezione referenziata dal parametro nell'oggetto fusione
for(cont=0; cont<=dimensioneRicevente; cont++){
fusione.collStr.addElement((String) coll.collStr.elementAt(cont));
}
}
/* Se invece non è rispettata la prprietà che la prima stringa del parametro contiene l'ultima stringa
della collezione ricevente solleva un'eccezione */
else throw new CollezioneParametroNonValidaExcepion();
// Alla fine, se non è stata sollevata l'eccezione ritorna l'oggetto creato e popolato
return fusione;
}
/* Iteratore */
private class MioIteratore implements Iterator{ // E' la classe interna che implementa l'interfaccia Iterator
public int dove; // Rappresenta la posizione all'interno della collezione su cui si itera
public MioIteratore(){ // Costruttore del generatore
dove = 0; // L'iterazione viene fatta partire dal primo elemento della collezione
}
public Object next(){ // Restituisce l'elemento correte della collezione su cui si stà iterando
return collStr.elementAt(dove);
}
public boolean hasNest(){ // Restituisce true se ci sono ancora elementi su cui iterare, false altrimenti
return dove < collStr.size();
}
public void remove(){ // Passa al prossimo elemento della collezione
dove++;
}
}
public Iterator enumera(){ // Maschero l'implementazione di MioIterator usando un metodo enumera
return MioIteratore();
}
}
Grazie
Rispondi quotando
). E nel next() dovresti nuovamente controllare se c'è un prossimo elemento, se c'è lo ritorni e comunque incrementi la posizione. Se non c'è un elemento si dovrebbe lanciare NoSuchElementException.
