Il numero di classi è assurdo, e pensare che originariamente il sistema I/O java era pensato per limitare l esplosione delle classi!

Transcript

1 1

2 Il numero di classi è assurdo, e pensare che originariamente il sistema I/O java era pensato per limitare l esplosione delle classi! 2

3 3

4 4

5 Se i dati sono in formato testo, allora sono rappresentati da caratteri, altrimenti da byte. Distinguiamo in questo modo file contenenti caratteri, detti anche file di testo e file contenenti sequenze di dati (che possono essere letti byte a byte) e che prendono il nome di file binari. È chiaro che il primo tipo è intelligibile dall uomo mentre il secondo non necessariamente lo è. 5

6 6

7 7

8 8

9 9

10 10

11 11

12 12

13 13

14 Un esempio in cui i flussi orientati ai caratteri non sono utili è la compressione. Se prendiamo ad esempio la libreria java.util.zip, essa è orientata ai byte: perché leggere caratteri quando abbiamo tra le mani contenuti che possono andare da un file immagine a una presentazione, tutti file di tipo binario? Non ha senso, ed infatti in questi casi si preferisci usufruire della lettura orientata ai byte. 14

15 15

16 16

17 Classi modificatori (si vedano le precedenti slide sul pattern decorator). 17

18 18

19 19

20 Per aprire un file per l input di caratteri potete utilizzare FileReader specificando il file da utilizzare con un oggetto String (rappresentante il path del file) o direttamente un oggetto File. Le prestazioni di lettura vanno però incrementate e invece di leggere ogni volta è meglio bufferizzare (cioè creare un buffer, un contenitore, che legge alcune righe e le mette a disposizione del programmatore); potete ottenere questo risultato incapsulando l oggetto in un BufferedReader (ecco un tipico esempio di pattern decorator!). La sezione b mostra come potete utilizzare i filtri nella lettura dell input da console con l oggetto System.in (che rappresenta appunto lo standard input, di default la console). Il tipo di quest ultimo è InputStream quindi, poiché BufferedReader necessita di un argomento Reader, viene utilizzata la classe InputStreamReader per eseguire l adattamento. 20

21 Questa sezione accetta la stringa s2 (dove è contenuto il file) e la utilizza per creare uno StringReader. Viene quindi utilizzato il metodo read() per leggere tutti i caratteri, uno di seguito all altro, e inviarli alla console. Notate che read() restituisce il byte letto come un int che, quindi, dev essere convertito in un char per essere stampato correttamente. Nulla vieta che usiate un decoratore per bufferizzare la stringa, scriviate cioè: BufferedReader b = new BufferedReader(new StringReader(s2)); usando poi il metodo readline(), di BufferedReader. Tramite StringReader la lettura avverrà carattere a carattere invece. Questo può essere uno dei pochi motivi per utilizzare BufferedReader con una stringa. 21

22 Per leggere dati formattati potete utilizzare un oggetto di tipo DataInputStream, che è una classe di I/O orientata ai byte (e non orientata ai caratteri). Di conseguenza, dovete utilizzare la gerarchia di classi basata su InputStream invece delle classi basate su Reader. Naturalmente, potete leggere qualsiasi oggetto (ad es. un file) come sequenza di byte utilizzando le classi InputStream ma, per comodità, in questo caso viene utilizzato un oggetto di tipo String. Per convertire la stringa in un array di byte, che è il tipo necessario per costruire un oggetto ByteArrayInputStream, è possibile usare il metodo getbytes() della classe String. A questo punto, avete un appropriato InputStream da gestire con la classe DataInputStream. 22

23 In primo luogo viene creato un oggetto FileWriter per connettersi al file. Praticamente sempre sarà utile bufferizzare l output utilizzando un BufferedWriter (i buffer, lo ricordiamo, migliorano sensibilmente l I/O da file). Quindi, per la formattazione, l oggetto BufferedWriter viene incapsulato in un PrintWriter. Il file di dati così creato è leggibile come un normale file di testo. Notate che il numero di righe non viene tenuto con LineNumberInputStream che è una classe di non facile gestione. Al termine del flusso di input, il metodo readline() restituisce null. Alla fine dell elaborazione potete osservare un operazione esplicita di close(). Questa operazione è necessaria poiché l uso di flussi bufferizzati non garantisce che il contenuto del buffer venga scritto fisicamente nel file nel momento in cui i metodi di scrittura sono stati invocati. Il metodo close() forza la scrittura dei dati ancora in memoria e chiude il file. 23

24 Gli oggetti della classe PrintWriter formattano i dati in modo che possano essere letti dalle persone. Viceversa, per eseguire l output dei dati in modo che possano essere letti da un altro flusso, dovrete utilizzare gli oggetti DataOutputStream (e gli oggetti DataInputStream per leggerli). Naturalmente, questi flussi possono essere di qualsiasi tipo, ma nell esempio viene utilizzato un file bufferizzato, sia per la lettura sia per la scrittura. Le classi Data.. Sono orientate ai byte per cui richiedono degli InputStream e degli OutputStream. Se si utilizza un DataOutputStream per scrivere i dati, Java garantisce di poter leggere correttamente i dati con un DataInputStream, in modo indipendente dal sistema utilizzato. Questo aspetto è particolarmente importante, poiché è ben noto quanto tempo può venire sprecato per risolvere eventuali problemi di porting dei dati verso uno specifico sistema. Se disponete di Java su entrambe i sistemi questo problema è completamente eliminato. Utilizzando un DataOutputStream, l unico modo affidabile per scrivere un oggetto di tipo String in modo che possa essere letto da un DataInputStream consiste nell usare la codifica UTF-8. Come è facile notare i metodi vengono chiamati dualmente: in scrittura viene chiamata la scrittura di un reale seguito da una stringa e infine un reale, in lettura viene letto un reale e quindi una stringa e di nuovo il reale. Tuttavia, affinchè tutti i metodi di lettura funzionino correttamente, dovreste conoscere la posizione esatta dell elemento nei dati del flusso, poiché sarebbe ugualmente possibile leggere il valore double memorizzato come semplice sequenza di byte, o come un valore char e così via. Di conseguenza, dovete avere un formato fisso per i dati presenti nel file oppure dovete memorizzare ulteriori informazioni nel file per determinare la posizione dei dati. 24

25 25

26 26

27 27

28 Esistono diverse classi File nel mondo Java, due delle quali inserite nel runtime Java distribuito dalla Sun. Quella cui ci riferiamo, e ci riferiremo sempre, è la classe contenuta in java.io: quando effettuate l import assicuratevi che sia questa la classe che inserite, altrimenti vi ritroverete con errori di difficile comprensione Come riportato in slide, la creazione di un nuovo file è possibile SOLO e SOLTANTO in una cartella (directory) già preesistente. Nel caso tentiamo di generare un file con un percorso la cui cartella non esiste, vedrete lanciare un eccezione e la creazione del file, ovviamente, non andrà a buon fine. Fate quindi attenzione e sfruttate i metodi messi a disposizione della classe File per verificare che le directory in cui state navigando esistano. 28

29 29

30 Unix utilizza / mentre Windows usa \ (ma viene accettato anche // ). Quest ultimo carattere non può essere usato direttamente in Java in quanto carattere di escape (cfr. le prime slide) per cui va escepato a sua volta ( \\ ). Ne segue che un percorso del tipo dir1/dir2/dir3 per ambiente linux, debba essere rappresentato come dir1\\dir2\\dir3\\ sotto Windows! Per ovviare a questi problemi possiamo sostituire i separatori con il membro statico di file riportato in slide. In questo modo otteniamo: dir1 + File.Separator + dir2 + File.Separator + dir3 30

31 31

32 32

33 33

34 Sotto windows il percorso relativo sarebbe:../../products/testo.txt ---- Ricordate sempre che la chiamata al metodo di creazione del nuovo file può lanciare un eccezione IOException e va quindi opportunamente circondata da un blocco try; alternativamente potete sempre demandare la gestione al chiamante del metodo (dichiarazione throws ). 34

35 35

36 36

37 37

38 38

39 39

40 Potete usare anche lo spazio, come fatto alla slide 38 dallo StringTokenizer: Stringa.split( ); 40

41 Se scriviamo: [abc]* viene accetta dalla regola qualsiasi sequenza di zero o più lettere abc, quindi ad esempio: aabac Acacbb e così via Se scriviamo invece: [a][1-9]* accettiamo sequenze composte dalla lettera a seguita da 1 o più cifre in base 10, diverse dallo 0 (con compreso). Quindi ad esempio: a a Ma non: Arfjnfj3443 A30049 B30903 E così via. 41

42 Il risultato è lo stesso dell applicazione di o : viene cercata una o più occorrenze di o sequenziali. Nel nostro testo le o sono però singole per cui, appunto, non si hanno risultati diversi. Ben differente è il caso di una stringa del tipo: moo:too:soo In questo caso, l applicazione dell espressione o provoca la generazione di diverse posizioni vuote, in particolare il risultato è: m,, :t,, :s (l ultimo vuoto viene eliminato da Java) Questo risultato è dovuto al fatto che viene riconosciuta una o alla volta per cui la divisione avviene sulla prima e poi sulla seconda, lasciando una stringa vuota. Ecco la sequenza di scissione: moo m o o o Viceversa nel caso dell espressione o+, vengono riconosciute anche le sequenze, per cui moo:too viene spezzata correttamente come segue: moo:too m oo too t oo *sequenza successiva* E si ottiene infatti come risultato m, :t, :s Che è decisamente di più facile gestione dell altro risultato dato dall espressione o. 42

43 43

44 44

45 Come la maggior parte dei flussi, in andrebbe sempre bufferizzato. 45

46 46

47 Il programma collega l input standard ad un file e reindirizza l output standard e il flusso di errore standard verso un altro file. Il re-indirizzamento dell I/O manipola flussi di byte, non flussi di caratteri. Per questo motivo vengono utilizzate le classi InputStream e OutputStream invece di Reader e Writer. 47

48 48

49 49

50 Tutte le classi collection sono tipizzate con Object, tutti i loro metodi che devono tornare degli elementi della collezione, tornano un oggetto (o un insieme di oggetti) di tipo Object. Perché, vi potreste chiedere. È molto semplice e dovreste intuirlo. Le collezioni devono poter contenere qualsiasi tipo di oggetto, sia definito nelle API, sia definito dall utente. Tutti gli oggetti ereditano da Object (gerarchia a radice unica) per cui tipizzando le collezioni su questo tipo, si garantisce che qualsiasi oggetto possa essere inserito nelle strutture dati Java. Il rovescio della medaglia è che nell inserimento si ha l upcast automatico (dal tipo inserito ad Object) e si perde (in realtà nasconde, come abbiamo visto parlando di ereditarietà) informazione sul contenuto effettivo della collezione. Noi sappiamo di aver inserito certi oggetti, però, per cui all estrazione possiamo effettuare il casting al tipo specifico desiderato. Chiaramente se commettiamo un errore nell inserimento, all estrazione e soprattutto al cast, avremo un errore e il lancio di un eccezione (ClassCastException). 50

51 51

52 Qualsiasi tipo di oggetto può essere una chiave, non esistono (e non possono ovviamente esistere) vincoli sulla natura e complessità della chiave scelta. 52

53 Se remove() viene chiamato senza mai chiamare next () oppure se remove() viene chiamato più di una volta in sequenza, si genera una IllegalStateException. Ricordate inoltre che non tutti gli iteratori supportano l operazione di remove() per cui potreste ottenere alla chiamata un eccezione UnsupportedOperationException. 53

54 54

55 Il richiamo di previous() subito prima di next() (e viceversa) restituisce il medesimo elemento attuale. 55

56 Nel caso di set() aggiungiamo che, se next() non è stato chiamato o se add() oppure remove() sono stati chiamati da poco, il metodo può generare una eccezione IllegalStateException ---- Ancora una volta fate attenzione: alcune di queste operazioni non sono supportate da tutte le collezioni, per cui potreste ricevere un UnsupportedOperationException. Non vi preoccupate, non è un vostro errore ma una limitazione della struttura dati che state usando! 56

57 Questo grafico riassume le relazioni tra interfacce e classi collection. Al top abbiamo l interfaccia Iterable che definisce il metodo getiterator() per ottenere un iteratore di scorrimento degli elementi della collezione: in questo modo la definizione del codice è del tutto generica e poi specializzata nella struttura dati considerata. Abbiamo poi una sua sottointerfaccia Collection cui afferiscono le interfacce di tre dei tipi base di strutture dati. Notate che le mappe non afferiscono alla stessa gerarchia per cui non possono essere definiti degli iteratori su di esse allo stesso modo delle altre. Come detto, comunque, si possono ottenere gli elementi chiave o gli elementi puntati dalle chiavi come oggetti Set e quindi usufruire degli iteratori su questi insiemi. Alternativamente potete ottenere una lista da una mappa e quindi iterare su quella. 57

58 58

59 59

60 60

61 61

62 ArrayList è la classe che potreste usare per gestire in maniera flessibile insiemi di oggetti del progetto. Esiste anche la classe Vector, del tutto simile a quella disponibile in C++. Non usatela. Si tratta di una classe legavy cioè mantenuta solo per motivi di compatibilità col vecchio codice che ne fa uso. In realtà ArrayList è più veloce sia nella lettura, sia nella scrittura, sia nell accesso casuale; a meno di specifici casi, dovrete sempre preferirla alla più vecchia Vector. Ricordate di importarla dal package util, per utilizzarla, attraverso la direttiva: import java.util.arraylist; 62

63 63

64 Quello riportato tra brackets ( <, > ) viene chiamato generic. Corrisponde (all incirca) ai template C++ e sarà presentato come ultimo argomento di questo set di slide. Per ora sappiate che usando questa forma stiamo tipizzando l oggetto ArrayList creato in maniera tale che possa contenere solo e soltanto oggetti di tipo String. Se così non facessimo, l oggetto lista accetterebbe oggetti Object e quindi anche qualsiasi altra istanza di qualsiasi altra classe oltre gli oggetti di String. 64

65 65

66 Notate che la terza parte del for, l incremento, è spostato nel corpo del metodo. Il for si struttura in 3 parti: - Dichiarazione - Controllo - incremento In questo caso l incremento non è presente (nelle parentesi del for al secondo ; non segue nulla!). Il motivo risiede nel fatto che l incremento, quello che dovrebbe essere inserito nelle parentesi tonde del for, ci ritorna effettivamente il prossimo elemento e non è un indice, possiamo quindi inserirlo nel corpo del for (metodo next()). Eseguiamo quindi l inizializzazione dell iteratore nella dichiarazione del for ed eseguiamo ogni volta il controllo (c è un ulteriore elemento nell iteratore hasnext()) per poi ottenerlo nel corpo del for come detto poco sopra. Alla chiamata viene effettuato il cast dato che la collezione contiene in linea teorica oggetti di tipo Object (in realtà la definizione con i generics, di alcune slide precedenti, ci permette di evitare questo cast ma lo vedremo poi). 66

67 La riga rossa modifica l oggetto riferito dalla variabile acct. Quando stamperemo le due liste, entrambi avranno il valore dell oggetto inserito uguale. L oggetto riferito, infatti, è lo stesso. 67

68 68

69 E ne esistono anche altri! Il comportamento della maggior parte di essi è facilmente deducibile dal loro nome. Vi invito comunque a consultare le API per maggiori dettagli sul loro funzionamento e uso. 69

70 Notate che in questo caso abbiamo concatenato la chiamata all iteratore con la chiamata next(), avevamo infatti coscienza di aver inserito un elemento nella lista e potevamo quindi chiamare subito il metodo next() per ottenerlo senza verifica della sua presenza (con hasnext()). Ovviamente avremmo potuto anche usare mialista.get(0), per avere il primo elemento inserito (effettivamente quello ritornato tramite la chiamata next() fatta nel codice). 70

71 71

72 72

73 73

74 74

75 75

76 Voi, ovviamente, non dovete mantenere compatibilità con alcun codice per cui assicuratevi di tipizzare sempre e comunque le collezioni che userete e di usare su di esse, sempre e comunque, iteratori tipizzati! 76

77 Il tipo è detto sconosciuto in questo caso ( unknown ). Qualsiasi lista tipizzata con qualsiasi tipo è accetta in questo contesto. 77

78 Java 5 mette a disposizione un nuovo for (detto for-each) che può essere utilizzato sia con le collection che derivano da Iterable (quindi tutte, tranne le map) e anche con gli array. 78

79 A seconda del caso, potete utilizzare il vecchio o il nuovo for. Molto dipenderà dalla necessità o meno di accedere agli indici della struttura dati dato che quest ultimi, come specificato nella slide, non sono disponibili se usate il for-each. 79

80 80

81 81

82 82

83 In altre parole, se volete assicurarvi una buona preparazione, usate come traccia per lo studio le slide di Tesei per gli argomenti che lui ha affrontato e le mie per gli argomenti che vi ho presentato io ma studiate sul libro! Sebbene sia un tomo di tutto rispetto (ma fidatevi, ne esistono di ben più grandi sull argomento!) non dovete studiarlo tutto dato che esso introduce argomenti avanzati che non abbiamo affrontato né io, né il prof. Tesei (concorrenza, GUIs, ecc ). 83

84 Buon lavoro! 84