Fondamenti di informatica
Oggetti e Java
Luca Cabibbo
Iterazione
Capitolo 17
febbraio 2004
1
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Accesso a sequenze
I problemi esaminati in questo capitolo hanno lo scopo di
accedere ed elaborare delle sequenze
 sequenze immesse dall’utente – lette dalla tastiera
 di lunghezza nota
 con un metodo che consente di sapere quando è stata
letta completamente
 di cui è noto l’ultimo elemento o una sua proprietà
 sequenze generate con una variabile di controllo
 sequenze ottenute scandendo gli elementi di una sequenza
con accesso posizionale
 file di testo
Queste tecniche possono essere applicate anche per altre
tipologie di sequenze
 array e collezioni
2
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Accumulazione
Accumulazione
 calcolare una proprietà sintetica (cumulata) da una sequenza
di valori
Tecnica dell’accumulazione
 una variabile di controllo (accumulatore)
 una operazione di accumulazione, binaria
3
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Lettura e somma di una sequenza di numeri interi
int numero;
int somma;
// elemento corrente della sequenza
// somma degli elementi della sequenza
/* leggi una sequenza di numeri interi e
* calcolane la somma */
/* inizialmente somma vale zero */
somma = 0;
/* finché ci sono altri elementi nella sequenza,
* leggili e sommali a somma */
while (!Lettore.in.eoln()) {
// finché ci sono
// altri elementi
/* leggi un elemento della sequenza */
numero = Lettore.in.leggiInt();
/* incrementa somma di numero */
somma = somma + numero;
}
/* visualizza somma */
System.out.println(somma);
4
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Fattoriale di un numero naturale
... calcola il fattoriale f di n ...
int f;
// il fattoriale di n
int i;
// per iterare tra 1 e n
/* calcola il fattoriale di n */
f = 1;
/* moltiplica f per ogni numero intero i
* compreso tra 1 e n */
for (i=1; i<=n; i++)
f = f*i;
... il fattoriale di n è f ...
5
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Invarianti di ciclo
In una istruzione ripetitiva, un invariante di ciclo è una proprietà
che risulta verificata
 ad ogni esecuzione del corpo dell’istruzione ripetitiva
 in un particolare punto del corpo dell’istruzione ripetitiva
Nel caso della lettura e somma di una sequenza di numeri
 un invariante di ciclo è che somma è uguale alla somma degli
elementi letti finora dalla tastiera
 il punto in cui la proprietà risulta verificata ad ogni esecuzione
del corpo dell’istruzione ripetitiva è al termine dell’esecuzione
del corpo
6
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Accumulazione
... dichiarazione della variabile accumulatore ...
accumulatore = elemento neutro dell’operazione
di accumulazione ;
... altre inizializzazioni ...
per ciascun elemento della sequenza {
... accedi al prossimo elemento ...
accumulatore = applica l’operazione di accumulazione
all’accumulatore e all’elemento
corrente ;
}
... altre elaborazioni ...
7
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Calcolo di una sottostringa
Scrivere un metodo di classe String sottostringa(String s, int
inizio, int fine) che calcola la sottostringa di s che consiste dei
caratteri compresi tra quello di posizione inizio e quello di
posizione fine-1
 sottostringa("automobile", 2, 6) deve restituire "tomo"
 usa solo le seguenti operazioni sulle stringhe
 int length()
 char charAt()
 + (concatenazione)
 motivazioni
 accesso posizionale su stringhe
8
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Calcolo di una sottostringa
/* Calcola la sottostringa di s compresa tra i
* caratteri di posizione da inizio a fine-1. */
public static String sottostringa(String s,
int inizio, int fine) {
// pre: s!=null &&
//
inizio>=0 && inizio<=s.length() &&
//
fine>=inizio && fine<=s.length()
String ss;
// la sottostringa di s tra inizio e fine
int i;
// indice per la scansione di s
/*
*
*
ss
calcola la sottostringa, come concatenazione
dei caratteri tra la posizione inizio (inclusa)
e fine (esclusa) */
= "";
// la stringa vuota è l'elemento neutro
// della concatenazione
for (i=inizio; i<fine; i++)
ss = ss + s.charAt(i); // concatenazione a destra
// e conversione automatica
return ss;
}
9
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Conteggio
I problemi di conteggio sono un caso particolare dei problemi di
accumulazione
 l’accumulatore è un contatore
 l’operazione di accumulazione è un incremento unitario
 l’aggiornamento deve essere eseguito sempre (conteggio),
oppure condizionatamente (conteggio condizionale) al
soddisfacimento di una proprietà da parte dell’elemento
corrente della sequenza
10
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Conteggio (condizionale)
int contaProprietà;
// numero di elementi che
// soddisfano la proprietà
contaProprietà = 0;
... altre inizializzazioni ...
per ciascun elemento della sequenza {
... accedi al prossimo elemento ...
if (l’elemento corrente soddisfa la proprietà)
contaProprietà++;
}
... altre elaborazioni ...
11
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Esercizio
Scrivere una applicazione che legge dalla tastiera una sequenza
di numeri interi e ne conta e visualizza, separatamente, il numero
degli elementi positivi e il numero degli elementi negativi (gli zeri
non vanno contati)
Scrivi una sequenza di numeri interi
10 20 0 -10 4 -8
La sequenza contiene 3 elementi positivi e 2 negativi
12
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Verifica esistenziale
I problemi di verifica esistenziale sono un altro caso particolare
dei problemi di accumulazione
 bisogna determinare se una sequenza di elementi contiene
almeno un elemento che soddisfa una certa proprietà
 come accumulatore può essere usata una variabile booleana
che indica se la sequenza contiene almeno un elemento che
soddisfa la proprietà
13
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Verifica se una sequenza contiene almeno uno zero
... legge una sequenza di numeri interi e
verifica se contiene almeno uno zero ...
int numero;
// elemento corrente della sequenza
boolean contieneZero;
// la sequenza contiene almeno
// un elemento uguale a zero
... visualizza un messaggio ...
/* legge la sequenza e verifica
* se contiene almeno uno zero */
contieneZero = false;
while (!Lettore.in.eoln()) {
/* legge il prossimo elemento della sequenza */
numero = Lettore.in.leggiInt();
/* se numero vale zero, allora la sequenza
* contiene almeno uno zero */
if (numero==0)
contieneZero = true;
}
... il risultato è contieneZero ...
14
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Verifica esistenziale
int contieneProprietà;
// almeno un elemento
// soddisfa la proprietà
contieneProprietà = false;
... altre inizializzazioni ...
per ciascun elemento della sequenza {
... accedi al prossimo elemento ...
if (l’elemento corrente soddisfa la proprietà)
contieneProprietà = true;
}
... altre elaborazioni ...
15
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Un errore comune
Un errore comune nella verifica esistenziale
contieneZero = false;
while (!Lettore.in.eoln()) {
/* legge il prossimo elemento della sequenza */
numero = Lettore.in.leggiInt();
/* se numero vale zero, allora la sequenza
* contiene almeno uno zero */
if (numero==0)
contieneZero = true;
else
contieneZero = false;
}
16
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Verifica universale
Un problema di verifica universale consiste nel verificare se tutti
gli elementi di una sequenza soddisfano una certa proprietà
 una variante (duale) dei problemi di verifica esistenziale
17
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Verifica se una sequenza di dieci elementi è crescente
... legge una sequenza di dieci numeri interi e
verifica se è crescente ...
int numero;
// elemento corrente della sequenza
int precedente;
// elemento che precede numero
// nella sequenza
int i;
// per contare i numeri letti
boolean crescente;
// la sequenza è crescente
/* il primo elemento della sequenza è il
* precedente del prossimo che sarà letto */
precedente = Lettore.in.leggiInt();
/* finora la sequenza letta è crescente */
crescente = true;
/* legge e elabora gli altri elementi della sequenza */
for (i=1; i<10; i++) {
/* legge il prossimo numero e verifica che
* la sequenza sia ancora crescente */
numero = Lettore.in.leggiInt();
if (precedente>=numero)
crescente = false;
/* prepara la prossima iterazione */
precedente = numero;
}
... il risultato della verifica è crescente ...
18
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Verifica l’uguaglianza tra stringhe
Scrivere un metodo boolean uguali(String s, String t) che
verifica se le stringhe s e t sono uguali
 uguali("alfa", "alfa") deve restituire true, mentre
uguali("alfa", "beta") deve restituire false
 due stringhe s e t sono uguali se
 s e t hanno la stessa lunghezza
 ciascun carattere della stringa s è uguale al carattere della
stringa t che occupa la stessa posizione
19
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Uguaglianza tra stringhe
/* Verifica se le stringhe s e t sono uguali. */
public static boolean uguali(String s, String t) {
// pre: s!=null && t!=null
boolean uguali;
// s e t sono uguali
int i;
// indice per la scansione di s e t
/* verifica se s e t sono uguali */
if (s.length()==t.length()) {
/* s e t hanno la stessa lunghezza: s e t
/* possono essere uguali, ma sono diverse
* se contengono almeno un carattere diverso */
uguali = true;
for (i=0; i<s.length(); i++)
if (s.charAt(i) != t.charAt(i))
uguali = false;
} else
/* s e t hanno lunghezza diversa,
* e quindi sono diverse */
uguali = false;
return uguali;
}
20
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Uguaglianza tra stringhe
Una variante
/* verifica se s e t sono uguali */
if (s.length()==t.length()) {
/* s e t hanno la stessa lunghezza: s e t
/* possono essere uguali, ma sono diverse
* se contengono almeno un carattere diverso */
uguali = true;
for (i=0; uguali && i<s.length(); i++)
if (s.charAt(i) != t.charAt(i))
uguali = false;
} else
/* s e t hanno lunghezza diversa,
* e quindi sono diverse */
uguali = false;
21
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Verifica universale
int tuttiProprietà;
// tutti gli elementi
// soddisfano la proprietà
tuttiProprietà = true;
... altre inizializzazioni ...
per ciascun elemento della sequenza {
... accedi al prossimo elemento ...
if (l’elemento corrente non soddisfa la proprietà)
tuttiProprietà = false;
}
... altre elaborazioni ...
22
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Ricerca
I problemi di ricerca sono un caso più generale dei problemi di
verifica esistenziale
 bisogna verificare se una sequenza contiene almeno un
elemento che soddisfa una certa proprietà
 in caso affermativo, bisogna calcolare delle ulteriori
informazioni circa uno degli elementi che soddisfa la proprietà
23
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Indice di un carattere in una stringa
Scrivere un metodo int posizioneDi(String s, char car) che
 verifica se la stringa s contiene almeno un carattere uguale a
car
 restituisce la posizione della prima occorrenza del carattere
car nella stringa s oppure il valore -1
 posizioneDi("alfa", 'f') deve restituire 2,
posizioneDi("alfa", 'a') deve restituire 1, mentre
posizioneDi("alfa", 'b') deve restituire -1
24
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Indice di un carattere in una stringa
/* Verifica se la stringa s contiene il carattere car,
* restituisce la posizione della prima
* occorrenza di car in s, oppure -1. */
public static int posizioneDi(String s, char car) {
// pre: s!=null
int posizione;
// posizione di car in s
int i;
// indice per la scansione di s
/* scandisce i caratteri di s alla ricerca della
* prima occorrenza di car in s */
/* finora non è stata trovato nessun car in s */
posizione = -1;
for (i=0; posizione==-1 && i<s.length(); i++) {
if (s.charAt(i)==car)
/* è stato trovato car in posizione i */
posizione = i;
}
return posizione;
}
25
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Ricerca
... info;
// informazione associata
// all’elemento cercato
info = informazione non trovata ;
... altre inizializzazioni ...
per ciascun elemento della sequenza {
... accedi al prossimo elemento ...
if (l’elemento corrente soddisfa la proprietà)
info = informazione associata
all’elemento corrente ;
}
... altre elaborazioni ...
26
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Indice di una sottostringa in una stringa
Scrivere un metodo int posizioneDi(String s, String t) che
 verifica se la stringa s contiene almeno una sottostringa
uguale alla stringa t
 restituisce la posizione in cui inizia la prima sottostringa di s
uguale a t oppure -1
 posizioneDi("sottostringa", "otto") deve restituire 1,
posizioneDi("mamma", "ma") deve restituire 0, mentre
posizioneDi("mamma", "pa") deve restituire -1
27
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Indice di una sottostringa in una stringa
/* Verifica se la stringa s contiene la sottostringa t
* e restituisce la posizione della prima
* occorrenza di t in s, oppure -1. */
public static int posizioneDi(String s, String t) {
// pre: s!=null && t!=null
int posizione;
// posizione della sottostringa t in s
int ls, lt;
// lunghezza di s e lunghezza di t
int i;
// indice per la scansione
// delle sottostringhe di s
int j;
// indice per la scansione di t
boolean ssug;
// la sottostringa di s che inizia in
// i ed ha lunghezza lt è uguale a t
... segue ...
28
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Indice di una sottostringa in una stringa
/* inizializzazioni */
ls = s.length();
lt = t.length();
/* scandisce le sottostringhe di s
* alla ricerca di una sottostringa uguale a t */
posizione = -1;
for (i=0; posizione==-1 && i<=ls-lt; i++) {
/* scandisce i caratteri di t per verificare
* se la sottostringa di s iniziante
* in posizione i e lunga lt è uguale a t */
ssug = true;
for (j=0; ssug && j<lt; j++)
if (s.charAt(i+j) != t.charAt(j))
ssug = false;
if (ssug)
// sottostringa di s uguale a t trovata
posizione = i;
// allora t è sottostringa di s
}
return posizione;
}
29
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Un’altra soluzione
public static int posizioneDi(String s, String t) {
// pre: s!=null && t!=null
int posizione;
// posizione della sottostringa t in s
int ls, lt;
// lunghezza di s e lunghezza di t
int i;
// indice per la scansione
// delle sottostringhe di s
/* inizializzazioni */
ls = s.length();
lt = t.length();
/* scandisce le sottostringhe di s alla ricerca di
* una sottostringa uguale a t */
posizione = -1;
for (i=0; posizione==-1 && i<=ls-lt; i++) {
if ( uguali(sottostringa(s,i,i+lt), t) )
posizione = i;
}
return posizione;
}
30
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
File di testo
Un file di testo è un documento che può essere generato da un
editor di testi
 un file di testo è una sequenza di linee
 una linea è una sequenza di caratteri
La classe Lettore del package fiji.io permette di leggere i file di
testo
 è possibile creare un oggetto Lettore per leggere da un file di
testo mediante il costruttore Lettore(FileReader f)
 un oggetto FileReader può essere creato usando il
costruttore FileReader(String nomefile)
 è possibile chiedere a un oggetto Lettore di leggere una linea
del file mediante il metodo String leggiLinea()
 è possibile chiedere a un oggetto Lettore se è stato letto tutto
il file che rappresenta mediante il metodo boolean eof()
 è possibile usare anche i metodi char leggiChar() e boolean
eoln()
31
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Lettura e visualizzazione di un file di testo
import fiji.io.*;
import java.io.*;
// per FileReader e IOException
/** Visualizza sullo schermo il contenuto
* del file di testo "lettura.txt". */
class LetturaFileDiTesto {
public static void main(String[] args)
throws IOException {
... codice dell'applicazione ...
}
}
La clausola throws dichiara che il metodo è consapevole che
durante la sua esecuzione possono verificarsi situazioni anomale
32
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Lettura e visualizzazione di un file di testo
final String NOME_FILE = "lettura.txt";
Lettore fin;
// per leggere dal file
String linea;
// una linea di testo
/* crea un oggetto Lettore per leggere
* dal file di nome NOME_FILE */
fin = new Lettore(new FileReader(NOME_FILE));
/* scandisce fin, riga per riga */
while (!fin.eof()) {
// finché ci sono altre linee da leggere
/* legge una linea e la visualizza */
linea = fin.leggiLinea();
System.out.println(linea);
}
33
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Lettura e visualizzazione, carattere per carattere
final String NOME_FILE = "lettura.txt";
Lettore fin;
// per leggere dal file
char car;
// il carattere corrente
34
/* crea un oggetto Lettore per leggere
* dal file di nome NOME_FILE */
fin = new Lettore(new FileReader(NOME_FILE));
/* scandisce fin, riga per riga */
while (!fin.eof()) {
// per ogni linea
/* scandisce una riga di fin */
while (!fin.eoln()) {
// per ogni carattere
/* legge un carattere e lo visualizza */
car = fin.leggiChar();
System.out.print(car);
}
/* "consuma" il terminatore di linea, preparando
* la lettura della linea successiva */
fin.leggiLinea();
/* va a capo nella visualizzazione */
System.out.println();
}
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Iterazione
Copyright © 2004 – The McGraw-Hill Companies srl
Scrittura di un file di testo
final String NOME_FILE = "scrittura.txt";
PrintWriter fout;
// per scrivere sul file
/* crea un oggetto PrintWriter per scrivere
* sul file di nome NOME_FILE */
fout = new PrintWriter(new FileWriter(NOME_FILE));
/* un oggetto PrintWriter sa eseguire le stesse
* operazioni di System.out */
/* scrive due linee di testo sul file */
fout.println("Una linea");
fout.println("Un'altra linea");
/* conclude la scrittura su file */
fout.close();
35
Iterazione
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Scarica

Iterazione