Generazione di file da Java

Nonostante lavori con Banche dati È un'ottima cosa e ci fa risparmiare un sacco di lavoro quando facciamo query e record relativi, ci sono momenti in cui abbiamo bisogno di generare file, poiché non abbiamo un server Banca dati disponibile o forse perché non abbiamo bisogno di salvare un record ma un set di dati non correlato.
La gestione dei file è un'area che molti vedono ancora come complessa o forse obsoleta, tuttavia questo non è corretto, la generazione di file è vitale nello sviluppo di sistemi e applicazioni. Un file può variare dalla generazione di a .testo con alcune linee in particolare, fino alla generazione di grandi .xml che possiamo definire una configurazione.
Per gestire tutto ciò che comporta la creazione di un file su un sistema, Giava contare sulla classe File all'interno del pacchetto della libreria per la gestione dell'input e dell'output dei dati java.io. Questa classe ci fornisce diversi metodi che ci permettono di eseguire operazioni che vanno da creare ed eliminare file, creare directory, convalidare permessi, ecc..
Prima di vedere in pratica come possiamo usare la classe per eseguire operazioni sui file, dobbiamo capire che fanno alcuni dei loro metodi principali, con questo avremo una base teorica a cui possiamo andare quando ci viene presentato un problema particolare che richiede gestione dei file nei nostri programmi:
esiste ()Questo metodo ci dà una risposta booleana sull'esistenza di un certo file in una directory che specifichiamo quando lo invochiamo, ovviamente restituisce vero o vero se il file viene trovato e falso o falso se non lo è.
getCanonicalPath()Questo metodo restituisce il nome completo compreso il percorso del file, è molto importante ottenere la posizione assoluta del nostro file all'interno del sistema dove stiamo eseguendo il nostro programma.
getNome()Contrariamente al metodo precedente, questo restituisce solo il nome relativo e breve del file, ovvero senza includere l'indirizzo o la cartella in cui si trova.
puòLeggere ()Questo metodo ci consente di verificare se abbiamo il permesso di leggere il file, è molto importante convalidare se possiamo leggere o meno un file prima di iniziare un'operazione con esso, in questo modo possiamo ridurre le eccezioni e risparmiare risorse di sistema.
canWrite()Questo è un altro metodo che ci aiuta a convalidare i permessi sui file, quando lo applichiamo su un'istanza della classe File ci farà sapere se possiamo scrivere il file corrispondente.
lunghezza ()Questo metodo è uno dei più utili in quanto ci permette di conoscere la dimensione di un file, un controllo importante in fase di elaborazione.
isFile()Infine, questo metodo ci permette di sapere se quello che stiamo valutando è un file o una directory, così sapremo se stiamo lavorando sulla struttura che vogliamo.
Il creazione di un file È un processo mediante il quale scriviamo all'interno del sistema in cui viene eseguito il nostro programma. C'è differenza tra scrivere un file e scrivere dentro un file, il primo ci dice che generiamo il file all'interno del sistema, ma non abbiamo necessariamente aggiunto il contenuto ad esso; D'altra parte, il secondo ci dice che aggiungiamo contenuto a un file esistente.
Potrebbero chiedersi perché vogliamo un file vuoto, un file vuoto non è inutile, può essere parte di un processo più ampio all'interno di un'applicazione, ad esempio un metodo crea il file e dopo un risultato di un processo, un altro metodo si occupa di aggiungere dati ad esso. Può anche essere vitale nelle convalide, dove generiamo file temporanei per indicare al programma in quale fase del processo ci troviamo, ecc.
Vediamo di seguito un piccolo codice in cui generiamo un file flat vuoto.

 import java.io.*; import java.io.File; public class CreateFiles {public static void main (String [] argv) genera IOException {if (argv.length == 0) {System.err.println ("Devi inserire un nome per parametro"); System.exit (1); } for (stringa nome file: argv) {nuovo file (nome file) .createNewFile (); }}} 

Vediamo che la prima cosa che facciamo è un'importazione delle classi di java.io per poter accedere alla gestione delle eccezioni con IOException, quindi importiamo la classe java.io.File che è ciò che ci consente di manipolare direttamente i file.
Quindi creiamo la nostra classe e nel suo metodo principale Indichiamo che riceverà argomenti, lo facciamo per indicare dinamicamente i nomi dei file. Poiché abbiamo bisogno di un nome, ciò che facciamo è una piccola convalida, che indica che se un nome di file non viene ricevuto, viene chiesto di inserirlo e il programma viene terminato. Infine per ogni argomento ricevuto creeremo un nuovo file, con questo quello che facciamo è una nuova istanza della classe File e con il metodo createNewFile() generiamo il file nel sistema.
Dobbiamo essere consapevoli che se il nostro programma non dispone di autorizzazioni sufficienti per creare un file nella sua directory, otterremo un errore. Senza ulteriori indugi, vediamo come appare il nostro programma quando lo eseguiamo sulla console:

INGRANDIRE

Possiamo vedere come ha funzionato la nostra convalida iniziale e poi quando abbiamo passato il nome del file è stato generato, per verificare quest'ultimo abbiamo semplicemente fatto un dir della nostra directory e quindi verifichiamo l'esistenza del file.
Un'altra delle operazioni più comuni quando si lavora con i file dopo la scrittura e l'eliminazione è la ridenominazione, per questo in Giava Dobbiamo seguire un processo che può sembrare complicato ma, come vedremo nell'esempio che accompagnerà la spiegazione, è qualcosa di abbastanza facile da capire.
Come farlo?Rinomina un file in Giava richiede due oggetti di tipo File, il primo conterrà il file che vogliamo rinominare e il secondo conterrà il nuovo nome del file, una volta soddisfatte queste condizioni dobbiamo chiamare il metodo rinomina in () sull'oggetto file esistente e passargli il nuovo oggetto con il nuovo nome.
Vediamo il codice che ci serve per eseguire l'operazione di ridenominazione sul nostro file:

 import java.io.*; import java.io.File; public class RenameFiles {public static void main (String [] argv) genera IOException {File FirstObject = new File ("NewFile.txt"); File secondooggetto = nuovo File ("FileWithNewName.txt"); PrimoOggetto.renameTo (SecondoOggetto); }} 

Importiamo le classi e i pacchetti corrispondenti, mantenendo lo stesso dell'esempio precedente.
Dentro il metodo principale () creeremo il nostro primo oggetto e metteremo il nome del file che avevamo creato nell'esempio precedente in questo caso è FileNuovo.txt. Quindi creiamo un secondo oggetto con il nuovo nome che vogliamo per il nostro file, nell'esempio che abbiamo scelto FileConNuovoNome.txt.
Infine al primo oggetto applichiamo il metodo rinomina in () e come argomento o parametro gli passiamo il secondo oggetto che ha il nuovo nome per il nostro file. Vediamo come appare sulla console quando eseguiamo il nostro codice:

INGRANDIRE

Abbiamo notato come la cartella è cambiata e ora riflette il nostro nuovo file rispetto all'esecuzione del primo esempio di creazione del file.
Infine vedremo l'altra operazione che è abbastanza comune quando si lavora con i file e cioè eliminare, questa è forse una delle più semplici, poiché abbiamo solo bisogno di conoscere il nome del file, convalidare che esiste e quindi procedere all'eliminazione usando il metodo Elimina () dove passeremo il nome del file in questione. Vediamo nel codice seguente come otteniamo questo:

 import java.io.*; import java.io.File; public class DeleteFile {public static void main (String [] argv) {delete ('FileWithNewName.txt'); } public static void delete (String filenameDelete) {try {File file = new File (filenameDelete); if (! file.exists ()) {System.err.println ("Il file" + filenameDelete + "non esiste in questa directory"); Restituzione; } if (file.delete ()) System.err.println ("** Il file" + fileNameDelete + "è stato eliminato **"); else System.err.println ("Impossibile eliminare il file:" + filenameDelete); } catch (SecurityException e) {System.err.println ("Impossibile eliminare il file:" + DeleteFileName + "(" + e.getMessage () + ")"); }}} 

Vediamo che questo programma è un po' più esteso dei precedenti, questo perché abbiamo creato un funzione riutilizzabile Per la cancellazione dei file, dove prima confermiamo che il file esiste, quindi procediamo alla cancellazione, qui convalideremo che è stato effettivamente cancellato, altrimenti informiamo l'utente che il file non può essere rimosso dal File System.
Nella console possiamo vedere come siamo stati in grado di eseguire con successo questa operazione, per questo utilizziamo il file che avevamo rinominato nell'esempio precedente, quindi quando creiamo un elenco dei contenuti della cartella vedremo riflessa la modifica:

INGRANDIRE

Infine proveremo a cancellare di nuovo in modo da poter osservare le convalide in funzione:

INGRANDIRE

Con questo concludiamo questo tutorial, abbiamo imparato a generare file, oltre a eseguire due delle azioni più utilizzate per la manipolazione dei file, con questo possiamo incorporare queste tecniche nei nostri programmi e applicazioni, godendo dei vantaggi che questo tipo di tecniche ti può portarci.