Altri modi per leggere dati in ingresso

Transcript

1 Errori Esiste anche un altra categoria di errori che si possono presentare durante l esecuzione e sono oggetti della classe Error. Può accadere che si occupi tutta la memoria disponibile; in questo caso viene lanciato l errore OutOfMemoryError e il programma si interrompe. Questo è un errore di tipo fatal error : non c è possibilità di porvi rimedio se non cambiando l algoritmo. Error ed Exception sono sottoclassi di Throwable; gli Error non hanno controllo da parte del compilatore. Altri modi per leggere dati in Per la gestione dell input e dell output in Java si possono utilizzare classi del pacchetto java.io della libreria standard. L input standard è l oggetto System.in della classe InputStream. Questa classe non ha metodi comodi per leggere numeri o stringhe, ha solo il metodo read che legge un singolo byte. Come abbiamo visto, quando abbiamo introdotto la classe Scanner, per acquisire i dati si inseriscono dei caratteri che vengono trasformati in binario e successivamente: 1) convertiti in una sequenza di caratteri, 2) tale sequenza viene poi convertita in una stringa. Con il flusso binario System.in possiamo solo leggere byte. Abbiamo bisogno di altri supporti. La gestione dell input in Java usa due diverse categorie di oggetti: i flussi di input (input stream) che leggono sequenze di byte, i lettori (reader) che leggono sequenze di caratteri. È possibile trasformare un flusso in un lettore. Per trasformare un flusso di input in un lettore di caratteri si usa la classe InputStreamReader. Gli oggetti della classe InputStreamReader leggono caratteri, ma leggono un carattere alla volta; noi, invece, vogliamo leggere un intera riga di input, fino al carattere Invio. Si potrebbe leggere un carattere alla volta e poi ricomporre la stringa totale, ma non è comodo. La classe BufferedReader trasforma un lettore a caratteri singoli in un lettore con buffer ( bufferizzato ), che può leggere una riga per volta. 1

2 Dovremo perciò costruire un lettore di caratteri e un lettore bufferizzato: InputSreamReader input = new InputStreamReader(System.in); trasforma il file binario in un lettore di caratteri BufferedReader in = new BufferedReader(input); trasforma il lettore di caratteri in un lettore di stringhe. L oggetto input di tipo InputStreamReader viene utilizzato soltanto per costruire l oggetto in di tipo BufferedReader, quindi non è necessario memorizzarlo in una variabile, si può utilizzare un unica istruzione: BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); Nella classe BufferedReader c è un metodo readline che legge una riga alla volta restituendo una stringa. Il metodo readline può sollevare l eccezione IOException. Questa eccezione è a controllo obbligatorio e quindi il metodo che utilizza readline deve dichiarare che può lanciare l eccezione. import java.io.inputstreamreader; import java.io.bufferedreader; import java.io.ioexception; public class Leggi{ public static void main(string arg[]) throws IOException{//main BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); String line = in.readline(); double a = Double.parseDouble(line); // }//fine main }//fine Leggi Il metodo readline può essere utilizzato nella versione interattiva ed interrompere la sequenza di con CtrlD che restituisce null: String line = in.readline(); while(line!= null){ //elabora line line = in.readline(); } I dati devono essere inseriti uno per riga; se si vogliono inserire più dati sulla stessa riga, per separarli si deve utilizzare la classe StringTokenizer. 2

3 Finora abbiamo visto programmi che utilizzano solo flussi di standard e questi flussi erano collegati attraverso la ridirezione ai corrispondenti file fisici. Vogliamo definire un file di lettura o di scrittura nel programma per poter leggere più di un file e poter gestire file diversi da System.in e System.out. Utilizzeremo le classi FileReader e FileWriter del pacchetto java.io. Per poter leggere caratteri da un file, esistente, occorre aprire il file in lettura; questa operazione si traduce in Java nella creazione di un oggetto di tipo FileReader. Il costruttore necessita del nome del file sotto forma di stringa. Se il file non esiste viene lanciata l eccezione FileNotFoundException. Supponiamo di leggere i dati da un file fisico di nome.txt. Costruiamo un oggetto di tipo FileReader: FileReader fl = new FileReader(.txt ); Con un oggetto di tipo FileReader si può invocare il metodo read, che legge un singolo carattere e lo restituisce sottoforma di intero compreso nell intervallo [0, 65535], iniziando dal primo carattere del file e procedendo fino alla fine del file stesso; se il file è finito il metodo read restituisce un intero che vale -1. Per facilitare l acquisizione dei dati si può usare un oggetto di tipo Scanner o di tipo BufferedReader: Scanner in = new Scanner(fl); e poi leggere con i metodi della classe Scanner, come in.nextint, oppure BufferedReader in = new BuffredReader(fl); e leggere con readline e poi utilizzare i metodi per la conversione ai vari tipi di dato. Al termine della lettura si deve chiudere il file: in.close(); Se il file non viene chiuso non viene segnalato nessun errore, ma è meglio eseguire la chiusura da programma. L eccezione FileNotFoundException è a controllo obbligatorio e quindi nell intestazione del metodo che apre il file si deve inserire: throws FileNotFoundException Per poter scrivere dei caratteri in un file, occorre aprire il file in scrittura; questa operazione si traduce in Java nella creazione di un oggetto di tipo FileWriter: FileWriter fs = new FileWriter( uscita.txt ); Il costruttore necessita del nome del file sotto forma di stringa. 3

4 Per poter usare i metodi print e println, si deve costruire un oggetto di tipo PrintWriter: PrintWriter out = new PrintWriter(fs); Il costruttore di PrintWriter accetta anche una stringa con il nome del file per cui si può più semplicemente srivere: PrintWriter out = new PrintWriter( uscita.txt ); Se il file non esiste, esso viene creato: viene costruito un file fisico con il nome indicato nella stringa ed in maniera sequenziale vengono inseriti i dati corrispondenti alle istruzioni del metodo print. Se il file esiste già, esso viene cancellato e poi costruito nuovamente, vale a dire sovrascritto: la testina di scrittura si riposiziona all inizio del file per inserire i nuovi dati. È necessario chiudere il file: out.close(); non viene segnalato alcun errore ma può succedere che il programma termini prima che i dati siano stati inseriti e pertanto il contenuto del file rimane incompleto. Se è presente l istruzione close il file deve essere chiuso prima della terminazione del programma, e il file viene chiuso solo se i dati sono stati tutti scritti nel file. La classe Scanner è stata progettata per rendere più comoda la lettura dei dati e pertanto è stato scelto di non legarla ad eccezioni di tipo controllato. Invece il metodo readline della classe BuferedReader solleva una eccezione controllata IOException, che pertanto deve essere indicata con la clausola throws. Dal momento che FileNotFoundException è una sottoclasse di IOException, se un metodo dovesse dichiararle entrambe, può dichiarare solo quelle superiore, vale a dire basta che indichi: throws IOEXception Le classi che gestiscono i file possono sollevare eccezioni che riguardano lo scambio di informazioni con l esterno (anche FileWriter può sollevare eccezioni) ed anche i metodi di lettura e i metodi per chiudere i file possono sollevare analoghe eccezioni. È conveniente scrivere sempre la clausola: throws IOException nell intestazione del main; questa eccezione deve essere importata: import java.io.ioexception Si può gestire l acquisizione dei nomi dei file tramite l utilizzo degli argomenti sulla riga di comando; in tale modo è possibile inserire un controllo almeno sul fatto di aver scritto i nomi (se i nomi sono errati e il file non esiste, si solleva l eccezione). Il parametro String arg[] viene ad avere per componenti i nomi dei file che si vogliono utilizzare. 4

5 /**Utilizzo di file lettore e scrittore */ import java.io.filereader; import java.io.filewriter; import java.io.bufferedreader; import java.io.printwriter; import java.io.ioexception; /* Si ricopia il contenuto di un file di testo una riga alla volta in un altro file; i nomi dei due file sono passati come parametri dalla riga di comando */ public class ProvaFile{ public static void main (String[] arg) throws IOException{ //inizio main if (arg.length < 2) System.out.println("dare i nomi" + "dei due file sulla riga " + " di comando\n"); else {//aprire i file BufferedReader in = new BufferedReader(new FileReader(arg[0])); PrintWriter out = new PrintWriter(new FileWriter(arg[1])); // acquisire dal file in una riga e scrivere // nel file out la stessa riga String line = in.readline(); while (line!= null){ out.println(line); line = in.readline(); }//fine while //chiusura dei due file out.close(); //file di scrittura in.close(); // file di lettura }//fine else }//fine main }//fine classe Dopo aver compilato e costruito il file da ricopiare dare il comando: java Provafile.txt uscita.txt Una scomposizione di un problema P in sottoproblemi P 1, P 2,, P n si dice ricorsiva se almeno uno dei sottoproblemi è formalmente simile a P e di dimensione inferiore. Esempio. Fattoriale di un numero naturale. Per definizione 0! = 1 (caso base) n! = n * (n-1)! Vediamo che n! viene definito tramite (n-1)! che è un numero più piccolo di n. 5

6 Per capire una definizione ricorsiva, bisogna espanderla : si ricopia la formula sostituendo al posto di n il numero n-1 e si prosegue fino al caso base : n! = n*(n-1)! = n* [(n-1) * (n-2)!] =... = = n*(n-1)*... * (n-n)! Poiché (n-n)! = 0! = 1 per definizione, si ottiene: n! = n*(n-1)*... * 1 Ci chiediamo se è una buona definizione. È una buona definizione perché esiste una dimensione del problema, una condizione, che non necessita di ulteriori scomposizioni; il problema viene risolto direttamente: 0! = 1 il problema per n=0 è risolto senza utilizzo della ricorsione. Possiamo scrivere algoritmi ricorsivi, algoritmi che richiamano se stessi. Il main non può essere ricorsivo: il main è richiamato dal Sistema Operativo. Un generico algoritmo ricorsivo avrà una struttura del tipo: se condizione allora risolvi direttamente altrimenti ricorsione oppure se condizione allora ricorsione In questo caso può esserci o meno una alternativa: se la condizione è falsa non si esegue nulla. Se la ricorsione non termina, si hanno infinite chiamate per l algoritmo e si può occupare tutta la memoria: questo è un errore grave, come quello di costruire un ciclo infinito. La scrittura di un algoritmo ricorsivo è semplice se si sta realizzando una formula matematica come quella del fattoriale: 0! =1, n! = n*(n-1)! Cosa accade veramente? Facciamo uno schema della scomposizione: n! intestazione del metodo fattoriale(n intero) definizione variabili f intero se n==0 allora f 1 altrimenti f n * fattoriale(n-1) //finese restituire f n* (n-1)* (n-1)! (n-2)! * 0! =1 6

7 I vari prodotti n*, (n-1)*, restano sospesi perché il controllo passa al metodo chiamato. Dopo l ultima chiamata che restituisce 1, si può ritornare indietro ed eseguire i prodotti sospesi. Come può un metodo rimanere sospeso e poi, quando si riattiva, eseguire i prodotti giusti? Il metodo ricorsivo avrà una scrittura del tipo: public static int fattoriale(int n){ int f; if(n == 0) f = 1; else f = n * fattoriale(n-1); return f; }//fine fattoriale ricorsivo Nel metodo appare n nell intestazione e n-1 nella chiamata. Una parte della memoria, RunTimeStack, mantiene le descrizioni delle attivazioni dei metodi: metodo M main. chiama M. quando si esegue l istruzione di invocazione di un metodo, il controllo passa al metodo e quando il metodo è terminato, il controllo ritorna al chiamante Con la ricorsione il metodo è sempre lo stesso, ma la gestione nel RunTimeStack è analoga: nelle varie copie del metodo sono memorizzati i parametri e le istruzioni di quella chiamata: f f f ritorno chiama f. chiama f. main chiama f.. il PC (contatore di programma) contiene l indirizzo della prossima istruzione da eseguire Che cosa deve essere memorizzato per poter eseguire le operazioni? Si deve memorizzare: quali sono le operazioni da eseguire prima e dopo la chiamata quale è il valore delle variabili a quel livello di chiamata. Vediamo un esempio di questa memorizzazione calcolando ricorsivamente 5! 1 * 0! 2 * 1! 3 * 2! ritorno 1 2*1 = 2 3*2 = 6 Quando un metodo termina, l area allocata ritorna libera. 4 * 3! 5 * 4! 4*6 = 24 5*24 =120 7

8 Complessità di un algoritmo ricorsivo Il tempo di un algoritmo ricorsivo si ottiene sommando vari tempi: il tempo delle operazioni eseguite nell algoritmo (esclusa la ricorsione) il tempo della chiamata del metodo il tempo dell algoritmo di dimensione inferiore Il tempo delle operazioni della parte non ricorsiva si calcola contando confronti, assegnazioni, cicli: T(n). Complessità di un algoritmo ricorsivo Il tempo per effettuare una chiamata è O(1): infatti si effettua un passaggio di parametri, in chiamata, e il ritorno di un valore, quando il metodo è terminato; questo equivale ad un numero finito di assegnazioni e pertanto è costante. Il tempo dell algoritmo di dimensione inferiore è T(dimensioneinferiore) Complessità di un algoritmo ricorsivo Esempio. Complessità dell algoritmo ricorsivo per il calcolo di n! Sia T(n) il tempo per calcolare n!: possiamo contare il numero di moltiplicazioni, dal momento che questa è l operazione fondamentale: costante se n=0 T(n) = costante + T(n-1) se n>0 Se contiamo solo le moltiplicazioni la prima costante è 0 e la seconda costante è 1. Complessità di un algoritmo ricorsivo Se vogliamo con precisione contare tutte le operazioni avremo: per la prima costante t c + t a + t ritorno per la seconda costante: t c + t prodotto + t chiamata + t a + t ritorno Otteniamo così la formula: T(n) = c + T(n-1) Complessità di un algoritmo ricorsivo Analogamente a quanto fatto con la definizione, espandiamo la formula: T(n) = c + T(n-1) = c + (c + T(n-2)) = 2c + T(n-2) = = 2c + (c + T(n-3)) = 3c + T(n-3) = = 3c + (c + T(n-4)) = 4c + T(n-4) =. = n c + T(n-n) = n c + T(0) = = (n+1) c O(n) Se avessimo contato le moltiplicazioni, avremmo avuto: T(n) = 1 + T(n-1) =. = n + T(0) = n e iterazione Avremmo anche potuto calcolare il fattoriale in maniera iterativa; la scomposizione iterativa del fattoriale è diversa: f f*1 f f*2 n! f f*n 8

9 e iterazione Anche la scrittura dell algoritmo cambia; possiamo scrivere delle istruzioni del tipo: intestazione del metodo fattiterativo(n intero) definizione variabili f, i intero f 1 per i da 1 a n eseguire f f * i //fineper restituire f e iterazione La complessità non cambia: abbiamo infatti una struttura iterativa che viene eseguita n volte: t a + (n+1) t p + n t a + t ritorno quindi sempre c n operazioni. Leonardo da Pisa (detto Fibonacci, ) fu un illustre matematico che si interessò di vari problemi, alcuni dei quali oggi potremmo chiamarli dinamica delle popolazioni, ossia lo studio di come si evolvono le popolazioni. Problema astratto. Consideriamo: un isola deserta: sistema isolato una coppia di conigli genera un altra coppia ogni anno i conigli si riproducono solo dopo due anni dalla loro nascita i conigli sono immortali (n + ) Quante coppie ci sono dopo n anni? Indichiamo con F n il numero di conigli dopo n anni e proviamo a calcolarli a partire dal primo anno: F 1 = 1 coppia iniziale F 2 = 1 la stessa coppia F 3 = = 2 F 1 + la coppia nata da F 1 ( 2 anni) F 4 = = 3 F 3 + la coppia nata da F 2 ( 2 anni) F 5 = = 5 F 4 + le due coppie nate da F 3 ( 2 anni).. In generale si avrà F n = F n-1 + F n-2 dove F n-1 rappresenta le coppie presenti l anno precedente ed F n-2 rappresenta una nuova coppia per ogni coppia di almeno 2 anni. I numeri si calcolano facilmente sommando i valori dei due posti precedenti (par. 12.4) : n F(n) L algoritmo più immediato da scrivere è quello che ricopia la definizione e pertanto è un algoritmo ricorsivo, che avrà una scrittura del tipo: intestazione metodo fibonacci (n intero) definizione variabili fib intero se n ==1 oppure n ==2 allora fib 1 altrimenti fib fibonacci (n-1) + fibonacci (n-2) //finese restituire fib 9

10 Possiamo rappresentare le chiamate ricorsive con una struttura di albero, come abbiamo fatto con il fattoriale. Un albero è un insieme di punti, detti nodi, a cui è associata una struttura d ordine che gode delle seguenti proprietà: esiste uno ed un solo nodo che precede tutti gli altri, detto radice ogni nodo, esclusa la radice, ha un unico predecessore immediato. Ogni nodo con successore si chiama padre. Ogni nodo con predecessore si chiama figlio. I nodi senza successore si chiamano foglie. L arco che collega un nodo padre a un nodo figlio si chiama ramo. Possiamo rappresentare l albero per n = 5. F 5 F 4 F 3 F 3 F 2 F 2 F 1 F 2 F 1 F 5 è la radice, F 1 e F 2 sono foglie; le foglie non hanno ulteriori chiamate ricorsive e restituiscono il valore 1 e nel ritorno si eseguono le somme. Si può dimostrare che il numero delle foglie dell albero della ricorsione per la costruzione di F n coincide con il valore di F n. Se vogliamo contare le chiamate del metodo, dobbiamo anche aggiungere il numero dei nodi interni, che corrisponde al numero delle chiamate ricorsive. Si può dimostrare che tale numero è uguale al numero delle foglie meno uno. Possiamo concludere che: la complessità dell algoritmo ricorsivo cresce come F(n). Osservando l albero della ricorsione si nota che molti valori F n sono calcolati più volte: nel caso di F 5, F 2 viene calcolato 3 volte. Si possono pertanto memorizzare tali valori in un array e calcolarli una volta sola. Si dovrà però dare una dimensione all array, stabilendo un numero massimo di elementi da calcolare. intestazione metodo fibonacci2 (n intero) definizione variabili fib[nummax], i intero fib[1] 1 fib[2] 1 per i da 3 a n eseguire fib[i] fib[i-1] + fib[i-2] //fineper restituire fib[n] 10

11 Quale complessità ha l algoritmo che utilizza l array? tempo O(n): ciclo che viene eseguito n volte spazio O(n): si utilizza un array di nummax componenti per calcolare F n con n<=nummax Si può scrivere un algoritmo ancora più efficiente. Osserviamo nuovamente il calcolo dei valori F n, ed osserviamo che ad ogni passo si utilizzano solo i valori precedenti, che possono essere salvati in due variabili scalari: F 1 = 1 F 2 = 1 F 3 = F 2 + F 1 F 4 = F 3 + F 2 F 5 = F 4 + F 3 queste somme sono del tipo: f f + valoreprecedente Si ottiene così il seguente algoritmo: intestazione metodo fibonacci3 (n intero) definizione variabili fib, i, prec, prec1 intero prec 1 //F1 fib 1 //F2 per i da 3 a n eseguire prec1 fib //salviamo F 2, prima di fib fib + prec // F 3 = F 2 + F 1 prec prec1 // perché servirà nel //fineper //calcolo di F 4 restituire fib Quale complessità ha l algoritmo che utilizza le sole variabili scalari? tempo spazio O(n): ciclo che viene eseguito n volte O(1): si utilizza un numero costante di locazioni di memoria Per calcolare la complessità dell algoritmo ricorsivo dobbiamo capire come il valore di F(n) cresce, andando all infinito. Possiamo stimare il valore utilizzando un algoritmo numerico. Si cerca una funzione che soddisfi la relazione di ricorrenza F n = F n-1 + F n-2 e si prova con a n, a 0; l equazione diventa: a n = a n-1 + a n-2 da cui raccogliendo a n-2 si ottiene: a n-2 ( a 2 a 1) = 0 Poiché a 0 cerchiamo le soluzioni dell equazione ( a 2 a 1) = 0 e troviamo le due radici reali: φ = (1 + 5 ) / 2 ~ φ = (1-5 ) / 2 ~ φ è la sezione aurea. Si può dimostrare che F n = (φ n -φ n ) / 5 11

12 Esiste quindi un algoritmo numerico con il quale calcolare il numero F n. Però tale algoritmo non può essere preciso, dal momento che F n è un numero naturale e la radice di 5 è un numero irrazionale: quindi una qualunque applicazione di tale algoritmo fornisce solo una approssimazione. La complessità di tempo e di spazio è O(1). Utilizziamo la formula F n = (φ n -φ n ) / 5 per stimare come F(n) + L algoritmo ricorsivo ha complessità O(F n ); dal momento che: φ < 1 si ha che φ n 0 1< φ < 2 si ha che φ n < 2 n e pertanto l algoritmo cresce in maniera esponenziale con limitazione superiore 2 n : tempo O(2 n ). F 4 F 3 F 3 F 2 F 2 F 1 F 2 F 1 F 5 La leggenda narra che dei sacerdoti di un tempio di Brahma lavorino per spostare una pila di 64 dischi d oro da un piolo ad un altro, utilizzandone uno di appoggio e seguendo delle regole; alla fine del lavoro ci sarà la fine del mondo La complessità di spazio è O(n); infatti le chiamate ricorsive si espandono in profondità, non sono contemporanee: F 5, F 4, F 3, F 2, ritorno, F 1, ritorno F 2, calcola F 3, ritorno, A B C La configurazione finale dovrà essere: A B C La regola è la seguente: si può spostare un solo disco alla volta non si può mettere un disco grande su uno piccolo. La soluzione più intuitiva è quella ricorsiva: se spostiamo la pila di n-1 dischi da A a B, possiamo muovere il primo disco da A a C e poi spostare la pila di n-1 dischi da B a C. Indichiamo con H(n, A, B,C) il problema di Hanoi di dimensione n (Esercizio P12.13). 12

13 La scomposizione ricorsiva sarà perciò: H(n-1, A, C, B) H(1, A, B, C) //muove un disco H(n-1, B, A, C) Possiamo scrivere le chiamate ricorsive nel caso n=3. Applichiamo l espansione della formula ricorsiva e vediamo come si muovono i dischi. H(3,A,B,C) H(2,A,C,B) H(1,A,B,C) H(2,B,A,C) H(1,A,B,C) H(1,A,C,B) H(1,C,A,B) H(1,B,C,A) H(1,B,A,C) H(1,A,B,C) Complessità. Quanti sono gli spostamenti ei dischi? Per spostare un disco da un piolo ad un altro, ed ottenere la stessa configurazione, si deve spostare 2 volte la pila di dischi che gli sta sopra; quindi ogni disco si muove un numero di volte che è doppio rispetto al disco che gli sta immediatamente sotto. Contiamo gli spostamenti a partire dal primo: disco 1 1 spostamento *2 = 4 = *4 = 8 = *8 = 16 = 2 4 n 2 n-1 sommiamo gli spostamenti n-1 = 2 n -1 quindi O(2 n ) l algoritmo è esponenziale Si può anche scrivere un algoritmo iterativo, che rimane esponenziale, osservando il movimento dei dischi: disco1 A C disco2 A B C disco3 A C B A C I dischi pari percorrono ciclicamente in ordine alfabetico i pioli, i dischi dispari li percorrono in ordine inverso. 13