Elenet.net
+1 voto

Implementazione della scrittura e lettura di in java con gestione dei ritorni a capo...

 
quesito posto 16 Gennaio 2014 in Classe quarta da Marco Scarpaci Corsista (94 punti)
modificato 2 Marzo 2014 da Gianni Messina
  

1 Risposta

+3 voti

Questo è il codice :

 

import java.io.*;
class File {
  public static void main (String args[]) {    
      try
     {
          FileOutputStream prova = new FileOutputStream("prova.txt");
          PrintStream scrivi = new PrintStream(prova);
          for(int i=0;i<10;i++)
          {
                scrivi.println("Testolina"+i);
          }
      }
      catch (IOException e)
      {
          System.out.println("Errore: " + e);
          System.exit(1);
      }
try
{
int a;
FileInputStream leggi = null;
leggi = new FileInputStream("prova.txt");
a=0;
while(a!=-1){
a=leggi.read();
if(a==13){
System.out.print("a capo");
 
}
System.out.print((char) a);}
 
 
 
}
 
catch (IOException e)
{
    System.out.println("Errore: " + e);
    System.exit(1);
}
  }}
 
risposta inviata 16 Gennaio 2014 da Marco Scarpaci Corsista (94 punti)
Documentazione sottoforma di commento nel programma:
 import java.io.*; // Importiamo la libreria per la gestione dei comandi in input e output
class File {
  public static void main (String args[]) {    
      try
    {    //Il comando "try" è obbligatorio in quanto stiamo lavorando su file.
          FileOutputStream prova = new FileOutputStream("prova.txt");
 /*Instanziamo un oggetto "prova" di tipo FileOutputStream
al quale passiamo "prova.txt", che è il file su quale dobbiamo effettuare delle operazioni. */
         
PrintStream scrivi = new PrintStream(prova);
/*Instanziamo un oggetto "scrivi" di tipo PrintStream
 * per farsì che possiamo scrivere all'interno del file*/
for(int i=0;i<10;i++)
{
scrivi.println("Testolina"+i);
}
/*Utilizziamo il ciclo "for". Esso effettua la scrittura su file,
 * in particolare all'interno del file troveremo "Testolina" e accanto
 * il numero di volte che il ciclo "for" ha effettuato questa operazione. */
      }
      catch (IOException e)
      {
          System.out.println("Errore: " + e); //In caso di errore, restituirà la seguente stringa: "Errore"
          System.exit(1);
      }
try
{
int a; //Dichiariamo una variabile a di tipo int
FileInputStream leggi = null; //Instanziamo un oggetto "leggi" di tipo FileInputStream
leggi = new FileInputStream("prova.txt"); /* All'oggetto "leggi" passiamo il file "prova.txt".
*Esso sarà il file da leggere durante le operazioni che andremo a fare successivamente. */
a=0;
while(a!=-1){
a=leggi.read();
/*Utilizziamo il ciclo "while" per far leggere il file al programma.
* Esso restituirà un errore se all'interno del file non c'è scritto nulla. */
if(a==13){
System.out.print("a capo");
}
/*Se il carattere da noi inserito nel file precedentemente sarà uguale a 13,
* in output verrà resistuita la stringa "a capo" */
System.out.print((char) a);} //Questo comando stamperà i caratteri corrispondenti a ciò che abbiamo scritto sul file.
}
//Senza il "char", ci restituirà in output il codice ASCII del carattere da noi inserito nel file.
 
catch (IOException e)
{
    System.out.println("Errore: " + e); //In caso di errore, restituirà la seguente stringa: "Errore" e uscirà dal programma.
    System.exit(1);
}
  }}
Questo è il codice commentato riga per riga :

import java.io.*;



class File {    
/*alla classe non inseriamo attributi e metodi, verrà eseguito tutto nel    main.*/
  public static void main (String args[]) {    
      try
/* inseriamo il try per la gestione delle eccezioni, quindi sarà analizzata la seguente parte di codice*/
     {
         FileOutputStream prova = new FileOutputStream("prova.txt");
/* Si instanza un oggetto "prova", della classe  FileOutputStram. All'oggetto gli passiamo il costruttore della classe "FileOutputStram" dentro le parentesi tonde gli passiamo il parametro ovvero il nome del file su cui si andrà ad operare.   */
         
 PrintStream scrivi = new PrintStream(prova);
 /* istanziamo un oggetto "scrivi" della classe PrintStream che servirà a scrivere all'interno del file sul parametro passato dal costruttore ovvero "prova".*/

          for(int i=0;i<10;i++)
/* con un ciclo for inseriamo per 10 volte il testo, che verrà salvato all'interno del file*/
          {
                scrivi.println("Testolina"+i);
 /* stamperà per 10 volte "testolina " con la sua relativa posizione ovvero "i"*/.
          }
      } /* chiusura del try, qui finisce il controllo per le eccezioni*/
    
  catch (IOException e)

/* dopo il try si inserisce il catch servirà per la gestione di un'evetuale eccezione rilevata all'ntero del try. Il catch gestirà solamente l'eccezione IOException che a sua volta sarà salvata sull' oggetto  "e" */
      {
          System.out.println("Errore: " + e);
// qui stamperà Errore con il tipo di errore generato.
          System.exit(1);
/* questo comando serve ad uscire dal catch ovvero dal programma al momento della generazione di un'eccezione*/
      }  //chiusura del catch
try // apertura di un nuovo catch
{
int a; // dichiariamo in variabile a di tipo int
FileInputStream leggi = null;
// instanziamo un oggetto "leggi" della classe FileImputStream
leggi = new FileInputStream("prova.txt");

/* a "leggi" gli passiamo il costruttore della classe FileInputStream e gli passiamo il paramtro cioè il file da cui deva leggere.*/

a=0; // prima di eseguire il while poniamo a=0, così partirà dalla prima posizione

while(a!=-1){
/* questo while legge carattere per carattere tutto il contenuto del codice fino ad arrivare a -1 ovvero la conclusione del programma*/
a=leggi.read();  
// a legge il contenuto del programma attraverso il metodo read della classe leggi
if(a==13){  // se a arriva a 13 ovvero "a capo" in ascii  stamperà "a capo"
System.out.print("a capo");
 
}
System.out.print((char) a);}
// quando avrà finito l'if convertirà tutto il contenuto di a in caratteri
 
 }// chiusura del try
 
catch (IOException e)
/* dopo il try si inserisce il catch servirà per la gestione di un'evetuale eccezione rilevata all'ntero del try.*/
/* il catch gestirà solamente l'eccezione IOException che a sua volta sarà salvata sull' oggetto  e */
{
    System.out.println("Errore: " + e);
    System.exit(1);
/* questo comando serve ad uscire dal catch ovvero dal programma al momento della generazione di un'eccezione*/
}
  }} // chiusura del catch, del main e della classe

Domande correlate

+1 voto
1 risposta
+5 voti
2 risposte
quesito posto 8 Gennaio 2014 in Classe quarta da Marco Zaccaria Corsista (149 punti) | 226 visite
+2 voti
1 risposta
quesito posto 20 Dicembre 2013 in Classe quarta da Gianni Messina Esperto (736 punti) | 382 visite
777 domande
1,565 risposte
639 commenti
1,445 utenti