Laboratorio di Informatica Applicata

Roberto Sassi
Università degli studi di Milano - Dipartimento di tecnologie dell'informazione

• Lez1e2
• Lez3e4
• Lez5e6
• Lez7e8
• Lez9e10
• Lez11e12
• Lez13e14
• Lez15e16
• Lez17e18
• Lez19e20
• Lez21e22
• Lez23e24

Utilizzo dei files. Javadoc

Martedì, 18 Ottobre 2005

Note

È molto importante complementare quanto visto a lezione con la lettura di un manuale Java. Per quanto riguarda il libro adottato, i capitoli trattati fino a questa lezione compresa sono: 1, 2, 3, 4, 6, 7, 8 [solo 8.1, 8.5, 8.6, 8.7], 9, 12, 14, 15.

Input/Output

Senza la possibilità di interagire con il resto del mondo, molti programmi sarebbero inutili. L'interazione di un programma con il resto del mondo è l'input/output. Storicamente, una delle parti più difficili nel design di un linguaggio di programmazione era la gestione dell'innumerevole quantità di sistemi di input o output. Java (come altri linguaggi di programmazione) utilizza una astrazione per rappresentare l'I/O: gli streams. Qualunque sia la periferica attraverso la quale vogliamo che il nostro programma comunichi, (un file, una connessione di rete, etc) ci basterà utilizzare lo stream opportuno.

Esistono due modi fondamentalmente diversi per memorizzare i dati:

• formato testo: vengono utilizzati dei caratteri per rappresentare l'informazione.

  Ad esempio il numero intero 161071 viene rappresentato dalla sequenza di quattro caratteri
  '1' '6' '1' '0' '7' '1'
  

• formato binario: è lo stesso utilizzato da Java per codificare molti dei tipi di dato primitivo.

  Ad esempio, lo stesso numero intero 161071 viene rappresentato dalla sequenza di 4 bytes:
  00000000 00000010 01110101 00101111
  

Tutte le volte che vorremo interagire con una periferica comunicando in formato testo dovremo utilizzare le classi Reader e Writer e le loro sottoclassi.

Quando invece vorremo utilizzare il formato binario dovremo utilizzare le classi InputStream e OutputStream (e loro sottoclassi).

Files

Operare con un file fondamentalmente significa:

1. Istanziare un oggetto della classe File
2. Istanziare uno stream opportuno (adatto a quanto vogliamo fare);
3. Leggere o scrivere almeno un carattere;
4. Gestire le eccezioni che possono presentarsi;
5. Chiudere lo stream

I/O da file in formato testo: BASE

• Per leggere da un file in formato testo, dobbiamo per prima cosa istanziare un oggetto della classe File:

  File fileAppunti = new File("appunti.txt");
  

• Per leggere dal file, dobbiamo creare uno stream FileReader connesso al file:

  FileReader appuntiLezione = new FileReader(fileAppunti);
  

  mentre per scrivere dobbiamo creare un oggetto FileWriter:

  FileWriter appuntiLezione = new FileWriter(fileAppunti);
  

  Questi oggetti associano al file uno stream, con il quale operare.
• Per leggere o scrivere un carattere si utilizzano i metodi istanza read() e write().
  Il metodo read() restituisce un intero con la codifica del carattere letto (sequendo le impostazioni standard per quanto riguarda, ad esempio la tabella di codifica dei caratteri). Se l'operazione di lettura non è riuscita, ad esempio perché abbiamo raggiunto la fine del file, restituisce -1.
• Molti dei metodi di I/O lanciano eccezioni della classe IOException. Queste eccezioni non possono essere trascurate e devono essere trattate, altrimenti la compilazione si interrompe con un messaggio di errore.
• Una volta che abbiamo finito di operare con il file dobbiamo chiudere lo stream associato.

  appuntiLezione.close();
  

Ad esempio ecco un programma che legge il file sanmartino.txt e lo stampa a video:

import java.io.*;

class SanMartino {
  public static void main (String[] args) throws IOException {
    File filePoesia = new File("sanmartino.txt");
    FileReader streamPoesia = new FileReader(filePoesia);
    int carattereLetto;

    while( (carattereLetto=streamPoesia.read()) != -1 ) {
      System.out.print((char)carattereLetto);
    }
    System.out.print('\n');

    streamPoesia.close();
  }
}

In questo altro esempio, il contenuto del file sanmartino.txt viene copiato, una volta reso maiuscolo, nel file sanmartinomaiuscolo.txt

import java.io.*;

class SanMartinoMaiuscolo {
  public static void main (String[] args) throws IOException {
    File filePoesiaIn = new File("sanmartino.txt");
    File filePoesiaOut = new File("sanmartinomaiuscolo.txt");

    FileReader streamPoesiaIn = new FileReader(filePoesiaIn);
    FileWriter streamPoesiaOut = new FileWriter(filePoesiaOut);

    int carattereLetto;
    char carattereDaScrivere;

    while( (carattereLetto=streamPoesiaIn.read()) != -1 ) {
      carattereDaScrivere = Character.toUpperCase((char)carattereLetto);
      streamPoesiaOut.write(carattereDaScrivere);
    }

    streamPoesiaIn.close();
    streamPoesiaOut.close();
  }
}

I/O da file in formato binario

L'I/O in formato binario è assolutamente analogo a quanto visto per i file in formato testo. A differenza di prima dobbiamo: per leggere istanziare un oggetto FileInputStream:

FileInputStream appuntiLezioneBinario = new FileInputStream(fileAppunti);

mentre per scrivere serve un oggetto FileOutputStream:

FileOutputStream appuntiLezioneBinario = new FileOutputStream(fileAppunti);

Anche in questo caso abbiamo a disposizione per leggere e scrivere i metodi read() e write().

I/O da file in formato testo: AVANZATO

Leggere semplicemente un carattere non è sempre ottimale. Molte volte quello che ci interessa è leggere da un file un numero (che è composto da più caratteri ad esempio). Per fare questo dobbiamo "incartare" ("wrap") lo steam di input in un BufferedReader. Lo stream viene ora riversato in un buffer e possiamo leggerne una linea alla volta, con il metodo readLine.
Per scomporre in parti la linea letta, possiamo utilizzare il metodo split(token) della classe String. token è un carattere separatore.
Vediamo ad esempio un programma che legge la seconda colonna del file altezze.txt e ne calcola la media.

import java.io.*;

class MediaAltezze {
  public static void main(String[] args) throws IOException {
    File fileAltezze = new File("altezze.txt");
    BufferedReader streamAltezze = new BufferedReader(new FileReader(fileAltezze));
    String lineaLetta;
    double media = 0;
    int numeroUtenti = 0;

    while( (lineaLetta = streamAltezze.readLine()) != null ) {
      String[] porzioniLineaLetta = lineaLetta.split("\t");
      media += Double.parseDouble(porzioniLineaLetta[1]);
      numeroUtenti++;
    }
    media/=numeroUtenti;

    System.out.println("La media delle altezze è " + media);
    streamAltezze.close();
  }
}

Anche scrivere un carattere alla volta non è sempre ottimale. Per esempio quando vogliamo scrivere un numero a virgola mobile in un file. Per semplificarci la vita, possiamo "incartare" lo stream testo di scrittura in un oggetto della classe PrintWriter. In questo modo possiamo utilizzare i metodi print() e println() che fanno per noi il lavoro di scrivere carattere per carattere la codifica della nostra variabile. Vediamo ad esempio un programma che genera 10 numeri casuali e li stampa nel file provatesto.txt:

import java.io.*;

class ProvaScrittura {
  public static void main(String[] args) throws IOException {
    double[] numeri = new double[10];
    for(int i=0; i<10; i++)
      numeri[i] = Math.random();

    File fileProvaTesto = new File("provatesto.txt");
    PrintWriter streamProvaTesto = new PrintWriter(new FileWriter(fileProvaTesto));

    for(int i=0; i<10; i++)
      streamProvaTesto.println(numeri[i]);

    streamProvaTesto.close();
  }
}

Il file provatesto.txt contiene:

0.17607143616534005
0.5401234521919662
0.3810251267294814
0.6677822896261097
0.9010739531281279
0.5243986237412629
0.19966383854395364
0.9257102581342692
0.9393950203062066
0.9813927079940031

La classe File

Su ogni oggetto della classe file possiamo operare in modo da svolgere tutte quelle operazioni necessarie per manipolare un file:

• exist(): verifica se il file esiste;
• delete(): cancella il file;
• length(): restituisce la dimensione del file.

Javadoc

In java esiste un metodo standard per scrivere i commenti. E' il terzo modo di inserire commenti in un file Java che vediamo.

/**
  * Return the real number represented by the string s,
  * or return Double.NaN if s does not represent a legal
  * real number.
  *
  * @param s String to interpret as real number.
  * @return the real number represented by s.
  */
public static double stringToReal(String s) {
  try {
    return Double.parseDouble(s);
  }
  catch (NumberFormatException e) {
    return Double.NaN;
  }
}

Tipici tag che possiamo utilizzare sono:

• @author nome: indica il nome dell'autore;
• @version testo: indica la versione;
• @param nomeParametro descizione: parametri di ingresso al metodo;
• @return descizioneValoreRitornato: valore ritornato dal metodo;
• @exception classeEccezione descizione: eccezioni prodotte.

Per produrre automaticamente la documentazione basta digitare dalla riga di comando:

javadoc nomefile.java

Costanti

In Java, per definire una costante possiamo utilizzare congiuntamente le parole chiave static final. Esempio:

public static final double PI = 3.14159;

Per convenzione le costanti hanno nomi tutti maiuscoli. Più parole si congiungono con un carattere "_". Esempio:

public static final int ALBERI_MELE = 20;

Soluzioni ad alcuni esercizi delle lezioni precedenti

Ecco alcune possibili soluzioni ad esercizi proposti nelle scorse esercitazioni.

Soluzioni all'esercizio 4 della lezione 6

class TriangoloNumeri {
  public static void main(String[] args) {
    for(int numeroRiga=1; numeroRiga<=9; numeroRiga++) {
      for(int numeroCarattere=1; numeroCarattere<=numeroRiga; numeroCarattere++) {
        System.out.print(numeroRiga);
      }
      System.out.print('\n');
    }
  }
}

Soluzioni all'esercizio 1 della lezione 10

Ecco tre possibili soluzioni.

import javax.swing.*;

class MassimoArrayDiDouble {
  public static void main(String[] args) {
    String stringaInput;
    double[] movimenti = new double[10];
    boolean inserimentoCorretto;

    for(int i=0; i<movimenti.length; i++) {
      stringaInput = JOptionPane.showInputDialog("Inserisci l'elemento numero " + i);
      inserimentoCorretto=false;
      try {
        movimenti[i] = Double.parseDouble(stringaInput);
        inserimentoCorretto=true;
      }
      catch(NumberFormatException e1) {
        while(inserimentoCorretto==false) {
          stringaInput = JOptionPane.showInputDialog("ATTENZIONE, hai immesso una stringa!\n" +
            "Inserisci invece l'elemento numero " + i);
          try {
            movimenti[i] = Double.parseDouble(stringaInput);
            inserimentoCorretto=true;
          }
          catch(NumberFormatException e2) {
            inserimentoCorretto=false;
          }
          catch(NullPointerException e2) {
            JOptionPane.showMessageDialog(null, "Arrivederci a presto!");
            System.exit(0);
          }
        }
      }
      catch(NullPointerException e1) {
        JOptionPane.showMessageDialog(null, "Arrivederci a presto!");
        System.exit(0);
      }
    }

    double minimo, massimo;
    int posizioneMassimo, posizioneMinimo;

    minimo = movimenti[0];
    posizioneMinimo = 0;
    massimo = movimenti[0];
    posizioneMassimo = 0;

    for(int i=1; i<movimenti.length; i++) {
      if(movimenti[i] > massimo) {
        massimo = movimenti[i];
        posizioneMassimo = i;
      }
      if(movimenti[i] < minimo) {
        minimo = movimenti[i];
        posizioneMinimo = i;
      }
    }

    JOptionPane.showMessageDialog(null, "Il massimo è " + massimo + " in posizione " + 
      posizioneMassimo + "\n" + "mentre il minimo è " + minimo + 
      " in posizione " + posizioneMinimo);

    System.exit(0);

  }
}

import javax.swing.*;

class MassimoArrayDiDouble2 {
  public static void main(String[] args) {
    String stringaInput;
    double[] movimenti = new double[10];
    boolean inserimentoCorretto;

    for(int i=0; i<movimenti.length; i++) {
      inserimentoCorretto=false;
      while(inserimentoCorretto==false) {
        stringaInput = JOptionPane.showInputDialog("Inserisci l'elemento numero " + i);
        try {
          movimenti[i] = Double.parseDouble(stringaInput);
          inserimentoCorretto=true;
        }
        catch(NumberFormatException e2) {
          inserimentoCorretto=false;
        }
        catch(NullPointerException e2) {
          JOptionPane.showMessageDialog(null, "Arrivederci a presto!");
          System.exit(0);
        }
      }
    }

    double minimo, massimo;
    int posizioneMassimo, posizioneMinimo;

    minimo = movimenti[0];
    posizioneMinimo = 0;
    massimo = movimenti[0];
    posizioneMassimo = 0;

    for(int i=1; i<movimenti.length; i++) {
      if(movimenti[i] > massimo) {
        massimo = movimenti[i];
        posizioneMassimo = i;
      }
      if(movimenti[i] < minimo) {
        minimo = movimenti[i];
        posizioneMinimo = i;
      }
    }

    JOptionPane.showMessageDialog(null, "Il massimo è " + massimo + " in posizione " + 
      posizioneMassimo + "\n" + "mentre il minimo è " + minimo + 
      " in posizione " + posizioneMinimo);

    System.exit(0);

  }
}

import javax.swing.*;

class MassimoArrayDiDouble3 {
  public static void main(String[] args) {
    String stringaInput;
    double[] movimenti = new double[10];
    boolean inserimentoCorretto;
    int numeroInserimenti;

    for(int i=0; i<movimenti.length; i++) {
      inserimentoCorretto=false;
      numeroInserimenti=0;
      while(inserimentoCorretto==false) {
        if(numeroInserimenti==0)
          stringaInput = JOptionPane.showInputDialog("Inserisci l'elemento numero " + i);
        else
          stringaInput = JOptionPane.showInputDialog("ATTENZIONE, hai immesso una stringa!\n" +
            "Inserisci invece l'elemento numero " + i);
        try {
          movimenti[i] = Double.parseDouble(stringaInput);
          inserimentoCorretto=true;
        }
        catch(NumberFormatException e2) {
          inserimentoCorretto=false;
          numeroInserimenti++;
        }
        catch(NullPointerException e2) {
          JOptionPane.showMessageDialog(null, "Arrivederci a presto!");
          System.exit(0);
        }
      }
    }

    double minimo, massimo;
    int posizioneMassimo, posizioneMinimo;

    minimo = movimenti[0];
    posizioneMinimo = 0;
    massimo = movimenti[0];
    posizioneMassimo = 0;

    for(int i=1; i<movimenti.length; i++) {
      if(movimenti[i] > massimo) {
        massimo = movimenti[i];
        posizioneMassimo = i;
      }
      if(movimenti[i] < minimo) {
        minimo = movimenti[i];
        posizioneMinimo = i;
      }
    }

    JOptionPane.showMessageDialog(null, "Il massimo è " + massimo + " in posizione " + 
      posizioneMassimo + "\n" + "mentre il minimo è " + minimo + 
      " in posizione " + posizioneMinimo);

    System.exit(0);

  }
}

Soluzione all'esercizio 3 della lezione 10

import javax.swing.*;

 /**
  * Cerca il numero di numero di ripetizioni in una sequenza composta solo da 
  * caratteri 'A' o 'B'
  *
  * @author Roberto Sassi
  * @version 1.0
  *
  */
public class CercaNumeroRipetizioni {
  public static void main(String[] args) {
    String sequenza;
    int i, j, lunghezzaSottosequenza;
    int ripetizioniA = 0, ripetizioniB = 0;

    sequenza = JOptionPane.showInputDialog("Inserisci la sequenza da analizzare");

    // Facciamo in modo che i caratteri della stringa di input siano maiuscoli
    sequenza = sequenza.toUpperCase();

    // Controlliamo che i caratteri immessi siano corretti
    for(i=0; i<sequenza.length(); i++) {
      if( (sequenza.charAt(i)!='A') && (sequenza.charAt(i)!='B') ) {
        JOptionPane.showMessageDialog(null, "La sequenza che hai immesso è illecita");
        System.exit(0);
      }
    }

    // Contiamo la lunghezza massima delle sottosequenze
    // Primo ciclo: scandisce le possibili sottosequenze
    i=0;
    while(i<sequenza.length()) {
      j=i+1;
      // Secondo ciclo: scandisce i caratteri all'interno della sottosequenza
      // All'uscita dal ciclo, j è la posizione del primo carattere che non appartiene
      // alla sottosequenza
      while( (j<sequenza.length()) && (sequenza.charAt(j)==sequenza.charAt(i)) ) {
        j++;
      }
      lunghezzaSottosequenza = j-i;

      if( (sequenza.charAt(i)=='A') && (lunghezzaSottosequenza>ripetizioniA) ) {
        ripetizioniA = lunghezzaSottosequenza;
      }
      if( (sequenza.charAt(i)=='B') && (lunghezzaSottosequenza>ripetizioniB) ) {
        ripetizioniB = lunghezzaSottosequenza;
      }

      i=j;
    }

    JOptionPane.showMessageDialog(null, "Il numero di A consecutive è " +
      ripetizioniA + "\nil numero di B consecutive è " + ripetizioniB);
    System.exit(0);
  }
}

La documentazione generata da Javadoc è la seguente: index.html

Lab