Java lit ligne par ligne à partir d'un fichier. Préparation de la méthode principale
Presque tous les concours de programmation fonctionnent avec des programmes console qui lisent quelque chose dans un fichier, effectuent des manipulations, puis écrivent le résultat dans un autre fichier. Et beaucoup sont ordinaires programmes de console fonctionnent sur le même principe. Nous verrons ici comment procéder.
Je vais considérer un moyen très simple de lire à partir d'un fichier et d'écrire dans un fichier pour que le code prenne un minimum de place, car aux mêmes Olympiades on a peu de temps pour écrire le code « correct ». Bien entendu, dans les applications pratiques, il sera nécessaire de prévoir de nombreux contrôles, gestion des exceptions, etc.
Fichiers
Nous créons un fichier input.txt avec le contenu suivant (les numéros que nous devons ajouter) :
ET fichier vide sortie.txt.
Placez-les dans votre dossier de projet :
Préparation de la méthode principale
Afin que nous n’ayons pas à nous soucier de la gestion des exceptions, nous allons écrire la ligne throws IOException pour la méthode main : 
Via Alt + Entrée, nous connecterons l'importation correspondante.
Lecture à partir d'un fichier
Vous pouvez lire les données d'un fichier de différentes manières: caractère par caractère, bit à bit, entièrement, etc. À mon avis, le moyen le plus simple consiste à lire simultanément toutes les lignes d'un fichier dans un tableau de lignes, puis à traiter ce tableau de lignes selon nos besoins.
Cela peut être fait comme suit :
Liste
Liste< String >lignes = Fichiers. readAllLines (Paths . get ( "input.txt" ) , Charset . defaultCharset () ) ; |
N'oubliez pas de connecter tous les packages en utilisant Alt + Entrée.
Maintenant notre tableau de lignes contient toutes les lignes de notre fichier. Traitez-les maintenant comme vous le souhaitez. Par exemple, vous pouvez parcourir toutes les lignes dans une boucle :
For (String x:lines) ( //traite toutes les lignes selon nos besoins)
pour (Chaîne x : lignes) // traite toutes les lignes selon nos besoins |
Mais dans notre cas, on sait d’avance qu’il n’y a que deux lignes avec deux nombres et c’est tout. Par conséquent, nous lisons simplement deux lignes du tableau lines et les convertissons en nombres :
int a = Integer.parseInt(lines.get(0)); int b = Integer.parseInt(lines.get(1));
Écrire dans un fichier
Il faut maintenant écrire le résultat dans un fichier.
Tout d’abord, écrivons ce que nous voulons enregistrer dans une variable texte :
Texte de chaîne = Integer.toString(c);
Texte de chaîne = Entier . àChaîne(c); |
Sauvons maintenant cette variable dans le fichier dont nous avons besoin :
PrintWriter out = new PrintWriter("output.txt"); out.println(texte); out.close();
PrintWriter out = new PrintWriter ( "output.txt" ) ; dehors . println(texte); dehors . fermer(); |
Texte final du programme :
package com.company; importer java.io.IOException ; importer java.io.PrintWriter ; importer java.nio.charset.Charset ; importer java.nio.file.Files ; importer java.nio.file.Paths ; importer java.util.List ; public class Main ( public static void main (String args) lève IOException ( List
int a = Integer.parseInt(lines.get(0)); int b = Integer.parseInt(lines.get(1)); int c = a + b; Texte de chaîne = Integer.toString(c); PrintWriter out = new PrintWriter("output.txt"); out.println(texte); |
out.close(); ) ) paquet com. entreprise; importer Java. io. IOException ; importer Java. io. PrintWriter ; importer Java. Non. jeu de caractères. Jeu de caractères ; importer Java. Non. déposer. Fichiers ;
Java 8 a facilité la vie des développeurs grâce à son nouvel ensemble de méthodes qui tirent parti de l'API de flux. De plus, plusieurs nouvelles méthodes ont été ajoutées à la classe Files qui utilisent toujours UTF-8 au lieu d'un encodage de plateforme personnalisé, tel que Files.readAllLines(). Cette méthode lit toutes les lignes d'un fichier. Les octets du fichier sont déchiffrés en caractères à l'aide du codage UTF-8. La méthode est équivalente Méthode Java 7 Files.readAllLines (chemin, StandardCharsets.UTF_8). À propos, spécifiez TOUJOURS explicitement le codage des caractères lorsque convertir un tableau d'octets en chaîne Chaîne. Spécifiez toujours l'encodage explicitement, même si votre fichier en cours de lecture est au format moment actuel contient uniquement l'anglais.
Lire un fichier avec une ligne de code Java7 et 8
Voici un exemple de notre programme Java montrant comment lire entièrement un fichier avec une seule ligne de code. Dans notre exemple, nous utilisons nouvelle classe Fichiers, introduite dans JDK 1.7, la classe java.nio.file.Files contient de nombreux méthodes utiles pour travailler avec des fichiers en Java, par exemple, vérifier si un fichier est caché, ou s'il est en lecture seule. Vous pouvez utiliser la commande Files.readAllBytes(Path) pour lire l'intégralité du fichier en mémoire. Cette méthode renvoie un tableau d'octets qui peut être transmis au constructeur String pour en créer chaînes Chaîne. Cela garantit également que le fichier est correctement fermé une fois tous les octets lus, ou si une erreur d'E/S ou toute autre exception non gérée se produit, ce qui signifie que vous n'avez pas besoin d'écrire du code passe-partout. Il convient de noter que cette méthode ne convient pas à la lecture gros fichiers, car s'il n'y en a pas assez dans le tas espace libre, vous risquez de manquer de mémoire. Vous devez également spécifier explicitement le codage des caractères lors de la conversion d'un tableau d'octets en chaîne pour éviter mauvaises surprises ou des erreurs d'analyse.
Si vous souhaitez lire le fichier sous forme de chaîne, vous pouvez utiliser une autre méthode appelée readAllLines (Path path, Charset cs). Cette méthode est similaire à la précédente, c'est-à-dire il ferme également les fichiers après la lecture ou si une erreur se produit, mais au lieu d'un tableau d'octets, il renvoie une chaîne convertie à partir d'octets en utilisant le jeu de caractères spécifié. De plus, Java 8 a ajouté une autre surcharge de cette méthode qui ne nécessite pas le paramètre Charset et utilise UTF-8 pour convertir les octets en chaîne.
Le plaisir ne s'arrête pas là. Si tu veux lire le fichier ligne par ligne, vous pouvez utiliser la méthode Files.lines(), qui renvoie un flux de lignes lues à partir d'un fichier, avec les octets convertis en caractères à l'aide du codage UTF-8. En utilisant méthode pour chaque(), vous pouvez imprimer toutes les lignes d'un fichier sur la console avec une seule ligne de code Java, comme démontré dans le troisième extrait de code.
importer java.io.IOException; importer importer java.nio.file.Files ; importer java.nio.file.Paths ; importer java.util.List; /** * Programme Java simple pour lire un fichier texte dans String en Java. *Vous pouvez l'utiliser une doublure code pour lecture rapide fichier et affichant * sous forme de chaîne.*@auteur Javin Paul */ classe publique Java78FileReadingExemple( vide statique public principal (arguments de chaîne) jette IOException(Système. dehors.println( nouveau Chaîne (Fichiers. lire tous les octets((Chemins. obtenir jette IOException(Système. dehors.println( nouveau Chaîne (Fichiers. lire tous les octets("data_old.txt")))); )))); Liste
Système.
); Système. jette ; );"Chaîne créée en lisant un fichier en Java" nouveau; );.println(fromFichier); /** * Système.);@auteur) Résultat : Java 7 et Java 8 ont rendu la lecture de fichiers en chaîne TRÈS FACILE. Société Générale est une banque française dont le siège social est situé en Île-de-France, France ++++++++++++++++++++++++ Chaîne créée en lisant un fichier en Java Java 7 et Java 8 a rendu la lecture de fichiers dans String TRÈS FACILE. +++++++++++++++++++++++++ classe publique Java78FileReadingExemple( vide statique public Vous pouvez rendre le code encore plus court en utilisant des importations statiques en Java, comme indiqué ci-dessous : jette IOException(Système. dehors importer de la statique nouveau(lire tous les octets((Chemins.)))); } }Si vous utilisez Java 8, vous pouvez également profiter de l'API Stream, qui vous permet d'écrire du code plus concis et plus performant, comme le montre l'exemple suivant. Ici, la méthode lines() renvoie un Stream of String, qui est converti à partir des octets lus dans le fichier en caractères à l'aide du codage UTF-8. Cela équivaut à appeler la méthode Files.lines(path, StandardCharsets.UTF_8) dans Java 7.
emballer test; importer java.io.IOException; importer java.nio.charset.StandardCharsets ; importer java.nio.file.Files ; importer java.nio.file.Paths ; /** * Programme Java pour montrer comment lire un fichier dans Java 8 à l'aide de Stream. * @auteur Javin Paul */@auteur Java8FileReader( classe publique Java78FileReadingExemple( vide statique public IOException( // DANSJava8 vous pouvez utiliserFluxet pour une optimisation plus poussée Fichiers. lignes Chaîne (Fichiers. lire tous les octets("manifest.mf"// Exemple Java 8 - Utilise le codage de caractères UTF-8 lignes = Fichiers. ).forEach(Système. jette ::println);) ) C'est tout ce que vous devez savoir pour lire un texte ou fichier binaire avec une seule ligne de code en Java 7. Comme vous pouvez le voir, le nouveau Outils de fichiers
- L'API du JDK 7 et l'API Stream de Java 8 ont grandement simplifié la tâche de lecture des données à partir de fichiers en Java. Cela nous a permis de nous débarrasser complètement du code passe-partout, ce qui a conduit à un code beaucoup plus compréhensible et concis. À propos, si vous écrivez du code de production qui lit les informations d'un fichier, n'oubliez pas de faire attention aux points suivants :
- Le fichier est peut-être trop volumineux pour tenir en mémoire, donc avant de le lire, examinez attentivement sa taille et envisagez les situations dans lesquelles vous ne pourrez pas lire le fichier.
- Conservez un journal de tous les messages expliquant pourquoi le fichier n'a pas pu être lu ou sur les erreurs survenues pendant le processus de lecture.
- Spécifiez toujours le codage des caractères lors de la lecture d'octets en caractères.
N'oubliez pas que le fichier peut être manquant, cette situation doit donc également être prise en compte. Classe de fichier , défini dans le package java.io, ne fonctionne pas directement avec les threads. Sa tâche est de gérer les informations sur les fichiers et les répertoires. Bien qu'au niveau système opérateur
les fichiers et les répertoires sont différents, mais en Java, ils sont décrits par la même classe File.
Selon que l'objet File doit représenter un fichier ou un répertoire, nous pouvons utiliser l'un des constructeurs pour créer l'objet :
Fichier (Chaîne chemin_répertoire) Fichier (Chaîne chemin_répertoire, Chaîne nom_fichier) Fichier (Répertoire de fichiers, Chaîne nom_fichier)
Par exemple:
La classe File dispose d'un certain nombre de méthodes qui vous permettent de gérer des fichiers et des répertoires. Examinons-en quelques-uns :
booléen createNewFile() : crée nouveau fichier le long du chemin qui est transmis au constructeur. Renvoie vrai si la création réussit, faux sinon
boolean delete() : Supprime un répertoire ou un fichier au chemin transmis au constructeur. Renvoie vrai si la suppression réussit.
boolean exist() : Vérifie si un fichier ou un répertoire existe au chemin spécifié dans le constructeur. Et si le fichier ou le répertoire existe, alors il renvoie vrai, sinon il renvoie faux
String getAbsolutePath() : Renvoie le chemin absolu du chemin passé au constructeur de l'objet
String getName() : renvoie le nom court d'un fichier ou d'un répertoire
String getParent() : renvoie le nom du répertoire parent
booléen isDirectory() : renvoie vrai, si par chemin spécifié le répertoire se trouve
boolean isFile() : renvoie true s'il y a un fichier dans le chemin spécifié
boolean isHidden() : renvoie true si le répertoire ou le fichier est masqué
long length() : renvoie la taille du fichier en octets
long lastModified() : renvoie l'heure dernier changement fichier ou répertoire. La valeur représente le nombre de millisecondes écoulées depuis le début de l'époque Unix.
String list() : renvoie un tableau de fichiers et sous-répertoires qui se trouvent dans un répertoire spécifique
File listFiles() : renvoie un tableau de fichiers et de sous-répertoires qui se trouvent dans un répertoire spécifique
booléen mkdir() : crée nouveau catalogue et à création réussie renvoie vrai
boolean renameTo(File dest) : renomme un fichier ou un répertoire
Travailler avec des catalogues
Si l'objet File représente un répertoire, alors sa méthode isDirectory() renvoie true . Et ainsi nous pouvons obtenir son contenu - sous-répertoires et fichiers imbriqués en utilisant méthodes de liste() et listFiles() . Récupérons tous les sous-répertoires et fichiers dans un répertoire spécifique :
Importer java.io.Fichier ; public class FilesApp ( public static void main(String args) ( // définit un objet pour le répertoire File dir = new File("C://SomeDir"); // si l'objet représente un répertoire if(dir.isDirectory( )) ( / / récupère tous les objets imbriqués dans le répertoire pour(File item: dir.listFiles())( if(item.isDirectory())( System.out.println(item.getName() + " \tdirectory") ; ) else( Système .out.println(item.getName() + "\tfile");
Effectuons maintenant un certain nombre d'opérations avec les répertoires, telles que supprimer, renommer et créer :
Importer java.io.Fichier ; public class FilesApp ( public static void main(String args) ( // définit un objet pour le répertoire de fichiers dir = new File("C://SomeDir//NewDir"); boolean créé = dir.mkdir(); if( créé) System.out.println("Le répertoire a été créé avec succès"); // renomme le répertoire File newDir = new File("C://SomeDir//NewDirRenamed"); // supprime le répertoire boolean supprimé = newDir . delete(); if(deleted) System.out.println("Répertoire supprimé" ) )
Travailler avec des fichiers
Travailler avec des fichiers est similaire à travailler avec un répertoire. Par exemple, récupérons les données de l'un des fichiers et créons un autre fichier :
Importer java.io.Fichier ; importer java.io.IOException ; public class FilesApp ( public static void main(String args) ( // définit un objet pour le répertoire de fichiers myFile = new File("C://SomeDir//somepicture.png"); System.out.println("File name : " + monFichier.getName()); System.out.println("Répertoire parent : " + monFichier.getParent()); if(monFichier.exists()) System.out.println("Le fichier existe"); out.println("Le fichier n'a pas encore été créé"); System.out.println("Taille du fichier : " + myFile.length()); le fichier est disponible en lecture "); else System.out.println("Le fichier n'est pas lisible"); if(myFile.canWrite()) System.out.println("Le fichier est accessible en écriture"); else System.out.println ("Fichier non accessible en écriture"); // crée un nouveau fichier File newFile = new File("C://SomeDir//MyFile"); try ( boolean create = newFile.createNewFile(); if(created) System.out .println ("Fichier créé"); catch(IOException ex)( System.out.println(ex.getMessage()); ) ) )
Lors de la création d'un nouveau fichier, la méthode createNewFile() lève une IOException si elle échoue, nous devons donc l'attraper, par exemple, dans un bloc try...catch, comme c'est le cas dans l'exemple ci-dessus.
Bien qu'en utilisant les classes évoquées précédemment, vous puissiez écrire du texte dans des fichiers, leurs capacités d'écriture travail à part entière Avec fichiers texte pas assez. Et à cette fin, des classes complètement différentes sont utilisées, qui sont les héritiers cours abstraits Lecteur et écrivain.
Enregistrement de fichiers. Classe FileWriter
La classe FileWriter dérive de la classe Writer. Il est utilisé pour écrire des fichiers texte.
Pour créer un objet FileWriter, vous pouvez utiliser l'un des constructeurs suivants :
FileWriter(Fichier fichier) FileWriter(Fichier fichier, ajout booléen) FileWriter(FileDescriptor fd) FileWriter(String fileName) FileWriter(String fileName, booléen ajout)
Ainsi, soit le chemin du fichier sous forme de chaîne, soit un objet File faisant référence à un fichier texte spécifique est transmis au constructeur. Le paramètre append spécifie si les données doivent être ajoutées à la fin du fichier (si le paramètre est vrai) ou si le fichier doit être écrasé.
Écrivons du texte dans le fichier :
Importer java.io.* ; public class FilesApp ( public static void main(String args) ( try(FileWriterwriter = new FileWriter("C:\\SomeDir\\notes3.txt", false)) ( // écrit la ligne entière String text = "Maman lavé le cadre, la mère a lavé le cadre du savon"; écrivain.write(text); // écriture par caractères écrivain.append("\n"); écrivain.append("E"); écrivain.flush(); ) catch( IOException ex)(System.out.println(ex.getMessage());
Le constructeur a utilisé le paramètre append avec la valeur false - c'est-à-dire que le fichier sera écrasé. Ensuite, à l’aide des méthodes définies dans la classe de base Writer, les données sont écrites.
Lecture de fichiers. Classe FileReader
La classe FileReader hérite de classe abstraite Reader et fournit des fonctionnalités pour lire des fichiers texte.
Pour créer un objet FileReader, nous pouvons utiliser l'un de ses constructeurs :
FileReader (String fileName) FileReader (Fichier fichier) FileReader (FileDescriptor fd)
Et en utilisant les méthodes définies dans la classe de base Reader, lisez le fichier :
Importer java.io.* ; classe publique FilesApp ( public static void main(String args) ( try(Fichier Lecteur lecteur= new FileReader("C:\\SomeDir\\notes3.txt")) ( // lit int c caractère par caractère; while((c=reader.read())!=-1)( System.out.print (( char)c); ) ) catch(IOException ex)( System.out.println(ex.getMessage()); ) ) )
Classe Déposer emballer java.io utilisé pour gérer les informations sur les fichiers et les répertoires. Au niveau du système d'exploitation, les fichiers et les répertoires présentent des différences significatives, mais en Java, ils sont décrits par une seule classe. Déposer. Un répertoire en Java est traité comme fichier régulier, mais avec une propriété supplémentaire - une liste de noms de fichiers, qui peuvent être visualisés à l'aide de la méthode liste.
Selon la destination de l'objet Déposer- fichier ou répertoire, vous pouvez utiliser l'un des constructeurs pour créer un objet :
Fichier (chaîne chemin_vers_répertoire) ; Fichier (String chemin_répertoire, Chaîne nom_fichier) ; Fichier (répertoire de fichiers, nom de fichier String);
Exemples de création d'objets Fichier
// Crée un fichier pour le répertoire File dir = new File("C://dir_test"); // Crée un fichier pour les fichiers qui se trouvent dans le répertoire File file1 = new File("C://dir_test", "Hello1.txt"); Fichier file2 = nouveau fichier (rép, "Hello2.txt");
Propriétés et méthodes de la classe File
Pour définir les propriétés de fichier standard dans une classe Déposer Il existe différentes méthodes. Cependant, la classe File est asymétrique, c'est-à-dire des méthodes pour déterminer les propriétés d'un objet existent, mais les fonctions correspondantes pour modifier ces propriétés manquent.
| Fonctions | Description |
|---|---|
| Chaîne getName() | Le nom du fichier ou du répertoire. |
| Chaîne getParent() | Le nom du répertoire parent. |
| longue longueur() | Fonction pour déterminer la taille du fichier en octets. |
| Chaîne getAbsolutePath() | Fonction de détermination chemin absolu fichier ou répertoire. |
| booléen supprimer() | Suppression d'un fichier ou d'un répertoire. |
| le booléen existe() | Vérifie l'existence d'un fichier ou d'un répertoire. |
| booléen isDirectory() | Vérifier si cet objet catalogue. |
| booléen isFile() | Vérifier si l'objet donné est un fichier. |
| longue dernièreModification() | Fonction permettant de déterminer la date de la dernière modification d'un fichier. |
| booléen canRead() | Vérifier si les données peuvent être lues à partir d'un fichier. |
| booléen canWrite() | Vérifier si les données peuvent être écrites dans un fichier. |
| booléen isHidden() | Vérifier si un répertoire ou un fichier est masqué. |
| Liste de chaînes() | Lecture d'un tableau de noms de fichiers et de sous-répertoires. |
| Liste de fichiersFichiers() | Lecture d'un tableau de fichiers et de sous-répertoires. |
| booléen mkdir() | Création d'un nouveau répertoire. |
| renameTo booléen (destination du fichier) | Renommez un fichier ou un répertoire. |
Dans l'exemple suivant, ouvrez le fichier "d:/test/MyFile.txt" (Windows) et extrayez ses caractéristiques :
Importer java.io.Fichier ; classe publique FileTest ( public static void main(String args) ( File fl = new File("d:\\test\\MyFile.txt"); System.out.println("Nom du fichier : " + fl .getName() ); System.out.println("Chemin : " + fl.getPath()); System.out.println(" Chemin complet: " + fl.getAbsolutePath()); System.out.println ("Répertoire parent : " + fl.getParent()); System.out.println (fl.exists() ? "Le fichier existe" : "Le fichier n'existe pas "); System.out.println (fl.canWrite() ? "Propriété - peut être écrite" : "Propriété - ne peut pas être écrite"); System.out.println (fl.canRead() ? "Propriété - peut être lu" : " Propriété - ne peut pas être lu"); System.out.println ("Est-ce un répertoire ? " + (fl.isDirectory() ? "yes": " no")); System.out.println ("Est-ce un fichier normal ? " + ( fl.isFile() ? "yes" : "no")); System.out.println("Dernière modification du fichier : " + fl. lastModified()); out.println("Taille du fichier : " + fl. length() + "octets");
Les informations suivantes seront imprimées dans la console :
Nom du fichier : MyFile.txt Chemin : d:\test\MyFile.txt Chemin complet : d:\test\MyFile.txt Répertoire parent : d:\test Le fichier existe Propriété - peut être écrit Propriété - peut être lu S'agit-il d'un répertoire ? non Est-ce un fichier normal ? oui Dernière modification du fichier : 1441710053162 Taille du fichier : 12 octets
Interface du filtre de fichiers
Classe Déposer inclut une méthode pour lire une liste de certains fichiers uniquement.
Liste de fichiers publicsFichiers (filtre FileFilter)
Contrairement à la méthode du même nom, mais sans paramètre, cette méthode sélectionne uniquement les fichiers répertoire qui satisfont à une certaine condition. Le paramètre filter est destiné à définir cette condition. Dans ce cas, le type de paramètre FiltreFichier- ce n'est pas une classe, mais une interface qui n'a qu'une seule méthode qui renvoie vrai si le fichier remplit certaines conditions, et faux dans le cas contraire.
Acceptation booléenne publique (chemin d'accès au fichier)
Méthode listeFichiers appellera la méthode accept pour chaque fichier du répertoire, et ceux pour lesquels accept renvoie true seront inclus dans la liste résultante. Le reste sera ignoré.
Pour utiliser FiltreFichier vous devez créer un objet et y définir la méthode correspondante accepter.
Class Filter implémente FileFilter ( String ext; Filter(String ext) ( this.ext = ext.split(","); ) private String getExtension(File pathname) ( String filename = pathname.getPath(); int i = filename. lastIndexOf("."); if ((i > 0) && (i< filename.length()-1)) { return filename.substring(i+1).toLowerCase(); } return ""; } public boolean accept(File pathname) { if (!pathname.isFile()) return false; String extension = getExtension(pathname); for (String e: ext) { if (e.equalsIgnoreCase(extension)) return true; } return false; } }
Exemple d'utilisation du filtre FileFilter
Importer java.io.Fichier ; importer java.io.FileFilter ; public class FileTest ( public static void main(String args) ( // Définir le répertoire de fichiers dir = new File("."); // Lecture liste complète fichiers du répertoire Fichier lst1 = dir.listFiles();
// Lecture d'une liste de fichiers répertoire avec les extensions "png" et "jpg" Fichier lst2 = dir.listFiles(new Filter("png,jpg"));
System.out.println("lst1.length = " + lst1.length + ", lst2.length = " + lst2.length); ) ) Lire le contenu d'un fichier FileInputStream
Pour lire le contenu d'un fichier, vous pouvez utiliser la classe
FichierInputStream
, qui est un héritier de la classe InputStream et implémente toutes ses méthodes. Constructeur de la classe FileInputStream :
Importer java.io.FileInputStream ; public class FilesApp ( public static void main(String args) ( try ( FileInputStream fis = new FileInputStream("C:\\test_dir\\test.txt"); System.out.println("Taille du fichier : " + fis.available () + " octet(s)"); int i = -1; while((i = fis.read()) != -1)( System.out.print((char)i); ) fis.close (); ) catch(IOException e)( System.out.println(e.getMessage()); ) ) )
Tampon d'octets = nouvel octet ; // lit le fichier dans le tampon fis.read (buffer, 0, fis.available()); System.out.println("Contenu du fichier :"); pour (int je = 0; je< buffer.length; i++){ System.out.print((char)buffer[i]); }
Classe ) ) conçu principalement pour travailler avec des fichiers binaires. Il peut être utilisé pour travailler avec des fichiers texte, mais d'autres classes sont encore plus adaptées à cette tâche.
Exemple d'utilisation ) ) pour lire un fichier de propriétés en encodage UTF-8 :
Fichier de propriétés "data.properties" en codage UTF-8 :
# # Paramètres du serveur SMTP # company=Gestionnaire des cornes et des sabots=Ostap Bender
Exemple de liste :
Importer java.io.Reader ; importer java.io.IOException ; importer java.io.InputStream ; importer java.io.FileInputStream ; importer java.io.InputStreamReader ; importer java.util.Properties ; public class Main ( public static void main(String args) ( try ( InputStream is = new FileInputStream("data.properties"); if (is != null) ( Reader reader = new InputStreamReader(is, "UTF-8") ; Propriétés props = new Properties(); props.load(reader); System.out.println(props.getProperty("company") + ", " props.getProperty("manager") ); ) ( e.printStackTrace(); ) ) )
Inscrivez-vous pour fichier Fichier Flux de sortie
Classe FichierOutputStream, est dérivé de la classe OutputStream, il hérite donc de toutes ses fonctionnalités.
Un exemple d'écriture d'une ligne dans un fichier :
Importez java.io.FileOutputStream ; public class FilesApp ( public static void main(String args) ( String text = " Bonjour le monde!"; // chaîne à écrire try ( FileOutputStream fos = new FileOutputStream("C:\\test_dir\\test.txt"); // conversion de la chaîne en octets byte buffer = text.getBytes(); fos.write( buffer , 0, buffer.length); ) catch(IOException e)( System.out.println(e.getMessage()); ) ) )
Pour créer un objet FichierOutputStream on utilise un constructeur qui prend en paramètre le chemin d'accès au fichier à écrire. Pour écrire une chaîne, nous la traduisons d’abord en un tableau d’octets et utilisons la méthode write pour écrire la chaîne dans un fichier. Il n'est pas nécessaire d'écrire l'intégralité du tableau d'octets. Utilisation de la surcharge de méthode écrire(), vous pouvez également écrire un seul octet :
Fos.write(tampon); // écrit uniquement le premier octet
Un exemple de réécriture de contenu d'un fichier à un autre :
Importer java.io.FileInputStream ; importer java.io.FileOutputStream ; public class FilesApp ( public static void main(String args) ( try ( FileInputStream fis = new FileInputStream("C:\\test_dir\\test.txt"); FileOutputStream fos = new FileOutputStream("C:\\test_dir\\new .txt"); byte buffer = nouvel octet; // lit le tampon fis.read(buffer, 0, buffer.length); // écrit du tampon dans le fichier fos.write(buffer, 0, buffer.length) ; fis. close(); fos.close(); ) catch(IOException e)( System.out.println(e.getMessage()); ) )
Classe FichierOutputStream destiné principalement à l'enregistrement fichiers binaires. Il peut être utilisé pour travailler avec des fichiers texte, mais d'autres classes sont encore plus adaptées à cette tâche.