Générer des fichiers à partir de Java

Malgré le travail avec Base de données C'est une très bonne chose et cela nous évite beaucoup de travail lors des requêtes et des enregistrements liés, il y a des moments où nous devons générer des fichiers, car nous n'avons pas de serveur Base de données disponible ou peut-être parce que nous n'avons pas besoin de sauvegarder un enregistrement mais un ensemble de données sans rapport.
La gestion de fichiers est un domaine que beaucoup considèrent encore comme complexe ou peut-être obsolète, mais cela est incorrect, la génération de fichiers est vitale dans le développement de systèmes et d'applications. Un fichier peut aller de la génération d'un .SMS avec quelques lignes en particulier, jusqu'à la génération de gros .xml que nous pouvons définir une configuration.
Afin de gérer tout ce qui implique la création d'un fichier sur un système, Java compter sur la classe Fichier dans le package de la bibliothèque pour la gestion de l'entrée et de la sortie des données java.io. Cette classe nous fournit différentes méthodes qui nous permettent d'effectuer des opérations allant de créer et supprimer des fichiers, créer des répertoires, valider des autorisations, etc..
Avant de voir en pratique comment nous pouvons utiliser la classe pour effectuer des opérations sur les fichiers, nous devons comprendre qu'ils font certaines de leurs méthodes principales, avec cela nous aurons une base théorique à laquelle nous pouvons aller lorsque nous sommes confrontés à un problème particulier qui nécessite traitement des fichiers dans nos programmes :
existe ()Cette méthode nous donne une réponse booléenne sur l'existence d'un certain fichier dans un répertoire que nous spécifions lors de l'appel, elle renvoie évidemment vrai ou vrai si le fichier est trouvé et faux ou faux s'il ne l'est pas.
getCanonicalPath ()Cette méthode renvoie le nom complet y compris le chemin du fichier, il est très important d'obtenir la position absolue de notre fichier dans le système où nous exécutons notre programme.
obtenirNom ()Contrairement à la méthode précédente, cela ne renvoie que le nom relatif et court du fichier, c'est-à-dire sans inclure l'adresse ou le dossier où il se trouve.
peut lire ()Cette méthode nous permet de vérifier si nous avons l'autorisation de lire le fichier, il est très important de valider si nous pouvons ou non lire un fichier avant de commencer une opération avec lui, de cette manière nous pouvons réduire les exceptions et économiser les ressources système.
peut écrire ()C'est une autre méthode qui nous aide à valider les permissions sur les fichiers, lors de son application sur une instance de la classe Fichier nous dira si nous pouvons écrire le fichier correspondant.
longueur ()Cette méthode est l'une des plus utiles car elle permet de connaître la taille d'un fichier, un contrôle important lors du traitement.
estFichier ()Enfin, cette méthode nous permet de savoir si ce que nous évaluons est un fichier ou un répertoire, ainsi nous saurons si nous travaillons sur la structure que nous voulons.
La création d'un fichier C'est un processus par lequel nous écrivons dans le système où notre programme s'exécute. Il y a une différence entre écrire un fichier et écrire à l'intérieur d'un fichier, la première nous dit que nous générons le fichier au sein du système, mais nous n'y avons pas forcément ajouté le contenu; Par contre, le second nous dit que nous ajoutons du contenu à un fichier existant.
Ils peuvent se demander pourquoi nous voulons un fichier vide, un fichier vide n'est pas inutile, il peut faire partie d'un processus plus large au sein d'une application, par exemple une méthode crée le fichier et après un résultat d'un processus, une autre méthode s'occupe d'ajouter données à celui-ci. Cela peut aussi être vital dans les validations, où nous générons des fichiers temporaires pour indiquer au programme dans quelle phase du processus nous nous trouvons, etc.
Voyons ci-dessous un petit code où nous générons un fichier plat vide.

 importer java.io.*; importer java.io.File; public class CreateFiles {public static void main (String [] argv) lève IOException {if (argv.length == 0) {System.err.println ("Vous devez entrer un nom par paramètre"); System.exit (1); } pour (chaîne de nom de fichier : argv) {nouveau fichier (nom de fichier) .createNewFile (); }}} 

Nous voyons que la première chose que nous faisons est une importation des classes de java.io pour pouvoir accéder à la gestion des exceptions avec IOException, puis nous importons la classe java.io.Fichier c'est ce qui nous permet de manipuler directement les fichiers.
Ensuite, nous créons notre classe et dans sa méthode principale Nous indiquons qu'il recevra des arguments, nous le faisons afin d'indiquer dynamiquement les noms des fichiers. Comme nous avons besoin d'un nom, ce que nous faisons est une petite validation, qui indique que si un nom de fichier n'est pas reçu, il lui est demandé de le placer et le programme est terminé. Enfin pour chaque argument reçu, nous allons créer un nouveau fichier, avec ce que nous faisons est une nouvelle instance de la classe Fichier et avec la méthode créerNouveauFichier () nous générons le fichier dans le système.
Nous devons être conscients que si notre programme ne dispose pas des autorisations suffisantes pour créer un fichier dans son répertoire, nous obtiendrons une erreur. Sans plus tarder, voyons à quoi ressemble notre programme lorsque nous l'exécutons sur la console :

AGRANDIR

On peut voir comment fonctionnait notre validation initiale et ensuite quand on a passé le nom du fichier il a été généré, pour vérifier ce dernier on a simplement fait un réal de notre répertoire et ainsi nous vérifions l'existence du fichier.
Une autre des opérations les plus courantes lorsque vous travaillez avec des fichiers après l'écriture et la suppression est de renommer, pour cela dans Java Nous devons suivre un processus qui peut sembler compliqué mais, comme nous le verrons dans l'exemple qui accompagnera l'explication, c'est quelque chose d'assez facile à comprendre.
Comment le faire?Renommer un fichier dans Java nécessite deux objets de type Fichier, le premier contiendra le fichier que l'on veut renommer et le second contiendra le nouveau nom du fichier, une fois ces conditions remplies il faudra appeler la méthode renommer en () sur l'objet fichier existant et transmettez-lui le nouvel objet avec le nouveau nom.
Voyons le code dont nous avons besoin pour effectuer l'opération de renommage sur notre fichier :

 importer java.io.*; importer java.io.File; public class RenameFiles {public static void main (String [] argv) lève IOException {File FirstObject = new File ("NewFile.txt"); Fichier secondobject = nouveau fichier ("FichierAvecNouveauNom.txt"); FirstObject.renameTo (SecondObject); }} 

Nous importons les classes et packages correspondants, en gardant le même que l'exemple précédent.
A l'intérieur de la méthode principale () nous allons créer notre premier objet et nous allons mettre le nom du fichier que nous avions créé dans l'exemple précédent dans ce cas c'est FichierNouveau.txt. Ensuite, nous créons un deuxième objet avec le nouveau nom que nous voulons pour notre fichier, dans l'exemple que nous avons choisi FichierAvecNouveauNom.txt.
Enfin au premier objet on applique la méthode renommer en () et comme argument ou paramètre nous lui passons le deuxième objet qui a le nouveau nom pour notre fichier. Voyons à quoi cela ressemble sur la console lorsque nous exécutons notre code :

AGRANDIR

Nous avons remarqué comment le dossier a changé et reflète maintenant notre nouveau fichier par rapport à l'exécution du premier exemple de création de fichier.
Enfin, nous verrons l'autre opération assez courante lorsqu'on travaille avec des fichiers et qui est de supprimer, c'est peut-être l'une des plus simples, puisqu'il suffit de connaître le nom du fichier, de valider qu'il existe puis de procéder à la suppression il en utilisant la méthode effacer () où nous passerons le nom du fichier en question. Voyons dans le code suivant comment nous y parvenons :

 importer java.io.*; importer java.io.File; public class DeleteFile {public static void main (String [] argv) {delete ('FileWithNewName.txt'); } public static void delete (String filenameDelete) {essayez {File file = new File (filenameDelete); if (! file.exists ()) {System.err.println ("Le fichier" + nomFichierSupprimer + "n'existe pas dans ce répertoire"); revenir; } if (file.delete ()) System.err.println ("** Le fichier" + fileNameDelete + "a été supprimé **"); else System.err.println ("Impossible de supprimer le fichier :" + nom de fichierSupprimer); } catch (SecurityException e) {System.err.println ("Impossible de supprimer le fichier :" + DeleteFileName + "(" + e.getMessage () + ")"); }}} 

On voit que ce programme est un peu plus étendu que les précédents, c'est parce que nous avons créé un fonction réutilisable Pour la suppression de fichiers, où nous validons d'abord que le fichier existe, puis nous procédons à sa suppression, ici nous validerons qu'il a bien été supprimé, sinon nous informons l'utilisateur que le fichier n'a pas pu être supprimé du système de fichiers.
Dans la console, nous pouvons voir comment nous avons réussi à exécuter cette opération, pour cela nous utilisons le fichier que nous avions renommé dans l'exemple précédent, donc lorsque nous dressons une liste du contenu du dossier, nous verrons le changement reflété :

AGRANDIR

Enfin, nous allons réessayer de supprimer afin de pouvoir observer le fonctionnement des validations :

AGRANDIR

Avec cela, nous terminons ce didacticiel, nous avons appris à générer des fichiers, en plus d'exécuter deux des actions les plus utilisées pour la manipulation de fichiers, avec cela nous pouvons incorporer ces techniques dans nos programmes et applications, en profitant des avantages que ce type de techniques vous peut nous apporter.