Java: la classe File e la gestione dei file

Per la scrittura e la lettura di file si usano gli stream (di input e/o di output) e per la gestione dei file?

Java realizza un utile classe per la manipolazione dei file, la classe File. Il metodo più semplice per creare un oggetto File è attraverso uno dei suoi costruttori:


File file=new File("file.dat");


che, attenzione, non crea il file! Viene creato un oggetto File che fa riferimento al path indicato nella stringa passata al costruttore. Altri possibili costruttori sono:

• File (String parent, String child);
  
• File (File parent, String child);

Entrambi i metodi prevedono come parametri la stringa con il nome del file (il secondo parametro da passare al costruttore) e quello della directory che deve ospitare il file. L'ultimo costruttore in elenco referenzia quest cartella con un oggetto File. Una directory è un file e quindi anche un oggetto della classe File!

Il riferimento generato dal costruttore, ovvero il collegamento logico fra la stringa con il path e/o il nome del file al file, avviene solo se il file esiste! Come faccio a sapere se ciò è avvenuto? Con il metodo exists():


String fileName="file.dat";
File file=new File(fileName);
if (file.exists()) System.out.println("Non ho trovato il file "+fileName+" !");
else System.out.println("Il "+fileName+" file esiste!");


Se non viene indicato un oggetto File per la directory parent, oppure viene passato al costruttore solo il nome del file, quest'ultimo viene allora cercato nella stessa cartella che ospita la classe. A proposito, ma l'oggetto fa riferimento a un file oppure a una directory?

if (file.isFile()) System.out.println("Il file "+fileName+" è un file!");
if (file.isDirectory()) System.out.println("Il file "+fileName+" è una directory!");


i metodi isFile() e isDirectory() interrogano l'oggetto File sulla sua reale natura ("sei file o directory?"). Vediamo adesso come raccogliere qualche informazione sul file (esistente). I metodi canExecute(), canRead() e canWrite() stabiliscono cosa può fare un'applicazione Java sul file e ritornano pertanto un valore booleano:

System.out.println("Il file "+fileName+":");
if (file.canExecute()) System.out.println(" - può essere eguito;");
if (file.canRead()) System.out.println(" - può essere letto;");
if (file.canWrite()) System.out.println(" - può essere modificato;");


Tali permessi possono essere modificati con setExecute(), setReadOnly() e setWriteable(). Tutti i metodi citati poco fa ricevono come parametro il valore booleano che assegna la proprietà al file (quindi true oppure false). Ovviamente le ultime operazioni dette riescono solo se l'esecutore dell'applicazione è il proprietario del file. Domanda: "se il file è scrivibile, quando è stato modificato l'ultima volta?" Ancora una volta esiste la risposta, basta usare il metodo lastModified():

if (file.canWrite()) System.out.println("Ultima modifica: "+new Date(file.lastModified()));


Il metodo lastModified() ritorna un long che esprime il tempo passato (in millisecondi) a partire da una data che Java assume come riferimento. Per convertire il valore ritornato da lastModified() in qualcosa di leggibile occorre passare questo valore al costruttore della classe Date (nel package java.util).

Il metodo length() ritorna la lunghezza in byte del file (se il file è una direcotory restituisce 0). Se vogliamo invece creare un file dobbiamo sempre referenziare l'oggetto File a un nome, con il costruttore visto prima, quindi invocare il metodo createNewFile(). L'esito dell'operazione restituisce un valore booleano. Tuttavia, se nella cartella corrente esiste già un file con il nome scelto l'esito restituito da createNewFile() sarà false! Non possono essere creati file con lo stesso nome. Questo metodo può lanciare un IOException che va quindi intercettata:

String fileName="file.dat";
File file=new File(fileName);
try {
   System.out.println("Il file "+fileName+" già esiste!");
}
catch(IOException e) {
   e.printStackTrace();
}


Per creare una directory possiamo usare il metodo mkdir(). Se l'operazione riesce il metodo ritorna true, altrimenti false. File e directory possono essere cancellati con delete() oppure rinominati con renameTo(). Esiste sempre un metodo a quello che ci serve! Un metodo particolarmente utile quando manipoliamo una directory è il metodo list() che ritorna un array di stringhe con i nomi dei file (ed eventualmente altre cartelle). Lo stesso lavoro viene poi eseguito da listFiles() che ritorna, invece, un array di oggetti File (è preferibile quindi usare quest'ultimo).


import java.io.*;
import java.util.*;

public class manageFile {
   public static void main(String[] args) {
      String fileName="file.dat";
      File file=new File(fileName);
      try {
         if(!file.createNewFile())
            System.out.println("Il file "+fileName+" già esiste!");
      }
      catch (IOException e) {
         e.printStackTrace();
      }
      System.out.print("Apertura del file \""+fileName+"\": ");
      if (!file.exists())
         System.out.println("\n - Non ho trovato il file "+fileName+"!");
      else {
         System.out.println("Ok!");
         if (file.isFile())
            System.out.println(" - Il file "+fileName+" è un file!");
         if (file.isDirectory())
            System.out.println(" - Il file "+fileName+" è una directory!");
System.out.println(" - Il file \""+fileName+"\"è:");
        if (file.canExecute())
           System.out.println("    - eseguibile;");
        if (file.canRead())
           System.out.println("    - leggibile;");
        if (file.canWrite()) {
           System.out.println("    - scrivibile;");
           System.out.println("       - ultima modifica: "+new Date(file.lastModified()));
         }
         System.out.println(" - Dimensione del file: "+file.length()+" byte");
      }
   }
}