Comment créer un fichier et y écrire en Java?

Quelle est la manière la plus simple de créer et d’écrire dans un fichier (texte) en Java?

Notez que chacun des exemples de code ci-dessous peut lancer une IOException . Les blocs try / catch / finally ont été omis pour des raisons de concision. Voir ce tutoriel pour plus d’informations sur la gestion des exceptions.

Créer un fichier texte (notez que cela écrasera le fichier s’il existe déjà):

 PrintWriter writer = new PrintWriter("the-file-name.txt", "UTF-8"); writer.println("The first line"); writer.println("The second line"); writer.close(); 

Créer un fichier binary (cela écrasera également le fichier):

 byte data[] = ... FileOutputStream out = new FileOutputStream("the-file-name"); out.write(data); out.close(); 

Les utilisateurs de Java 7+ peuvent utiliser la classe Files pour écrire dans des fichiers:

Créer un fichier texte:

 List lines = Arrays.asList("The first line", "The second line"); Path file = Paths.get("the-file-name.txt"); Files.write(file, lines, Charset.forName("UTF-8")); //Files.write(file, lines, Charset.forName("UTF-8"), StandardOpenOption.APPEND); 

Créer un fichier binary:

 byte data[] = ... Path file = Paths.get("the-file-name"); Files.write(file, data); //Files.write(file, data, StandardOpenOption.APPEND); 

En Java 7 et plus:

 try (Writer writer = new BufferedWriter(new OutputStreamWriter( new FileOutputStream("filename.txt"), "utf-8"))) { writer.write("something"); } 

Il existe cependant des utilitaires utiles:

  • FileUtils.writeSsortingngtoFile (..) de commons-io
  • Files.write (..) de goyave

Notez également que vous pouvez utiliser un FileWriter , mais il utilise le codage par défaut, ce qui est souvent une mauvaise idée – il est préférable de spécifier explicitement le codage.

Ci-dessous la réponse originale à Java 7


 Writer writer = null; try { writer = new BufferedWriter(new OutputStreamWriter( new FileOutputStream("filename.txt"), "utf-8")); writer.write("Something"); } catch (IOException ex) { // Report } finally { try {writer.close();} catch (Exception ex) {/*ignore*/} } 

Voir aussi: Lecture, écriture et création de fichiers (inclut NIO2).

Si vous avez déjà le contenu que vous souhaitez écrire dans le fichier (et non généré à la volée), l’ajout java.nio.file.Files dans Java 7 dans le cadre des E / S natives constitue le moyen le plus simple et le plus efficace de réaliser tes objectives.

Fondamentalement, créer et écrire dans un fichier est une seule ligne, en plus d’ un simple appel de méthode !

L’exemple suivant crée et écrit dans 6 fichiers différents pour montrer comment il peut être utilisé:

 Charset utf8 = StandardCharsets.UTF_8; List lines = Arrays.asList("1st line", "2nd line"); byte[] data = {1, 2, 3, 4, 5}; try { Files.write(Paths.get("file1.bin"), data); Files.write(Paths.get("file2.bin"), data, StandardOpenOption.CREATE, StandardOpenOption.APPEND); Files.write(Paths.get("file3.txt"), "content".getBytes()); Files.write(Paths.get("file4.txt"), "content".getBytes(utf8)); Files.write(Paths.get("file5.txt"), lines, utf8); Files.write(Paths.get("file6.txt"), lines, utf8, StandardOpenOption.CREATE, StandardOpenOption.APPEND); } catch (IOException e) { e.printStackTrace(); } 
 public class Program { public static void main(Ssortingng[] args) { Ssortingng text = "Hello world"; BufferedWriter output = null; try { File file = new File("example.txt"); output = new BufferedWriter(new FileWriter(file)); output.write(text); } catch ( IOException e ) { e.printStackTrace(); } finally { if ( output != null ) { output.close(); } } } } 

Voici un petit exemple de programme pour créer ou écraser un fichier. C’est la version longue donc on peut la comprendre plus facilement.

 import java.io.BufferedWriter; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStreamWriter; import java.io.Writer; public class writer { public void writing() { try { //Whatever the file path is. File statText = new File("E:/Java/Reference/bin/images/statsTest.txt"); FileOutputStream is = new FileOutputStream(statText); OutputStreamWriter osw = new OutputStreamWriter(is); Writer w = new BufferedWriter(osw); w.write("POTATO!!!"); w.close(); } catch (IOException e) { System.err.println("Problem writing to the file statsTest.txt"); } } public static void main(Ssortingng[]args) { writer write = new writer(); write.writing(); } } 

Utilisation:

 try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8))) { writer.write("text to write"); } catch (IOException ex) { // Handle me } 

Utiliser try() fermera le stream automatiquement. Cette version est courte, rapide (mise en mémoire tampon) et permet de choisir l’encodage.

Cette fonctionnalité a été introduite dans Java 7.

Un moyen très simple de créer et d’écrire dans un fichier en Java:

 import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; public class CreateFiles { public static void main(Ssortingng[] args) { try{ // Create new file Ssortingng content = "This is the content to write into create file"; Ssortingng path="D:\\a\\hi.txt"; File file = new File(path); // If file doesn't exists, then create it if (!file.exists()) { file.createNewFile(); } FileWriter fw = new FileWriter(file.getAbsoluteFile()); BufferedWriter bw = new BufferedWriter(fw); // Write in file bw.write(content); // Close connection bw.close(); } catch(Exception e){ System.out.println(e); } } } 

Référence: Exemple de création de fichier en Java

Ici, nous entrons une chaîne dans un fichier texte:

 Ssortingng content = "This is the content to write into a file"; File file = new File("filename.txt"); FileWriter fw = new FileWriter(file.getAbsoluteFile()); BufferedWriter bw = new BufferedWriter(fw); bw.write(content); bw.close(); // Be sure to close BufferedWriter 

Nous pouvons facilement créer un nouveau fichier et y append du contenu.

Si vous souhaitez vivre une expérience relativement FileUtils vous pouvez également consulter le package Apache Commons IO , plus précisément la classe FileUtils .

N’oubliez jamais de vérifier les bibliothèques tierces. Joda-Time pour la manipulation des dates, Apache Commons Lang SsortingngUtils pour les opérations sur les chaînes de caractères courantes et autres peut rendre votre code plus lisible.

Java est un excellent langage, mais la bibliothèque standard est parfois un peu faible. Puissant, mais néanmoins bas.

L’auteur n’ayant pas précisé s’il avait besoin d’une solution pour les versions Java EoL’d (Sun et IBM, qui sont techniquement les JVM les plus répandues), et parce que la plupart des utilisateurs semblent avoir répondu à la question de l’auteur avant qu’il soit spécifié qu’il s’agit d’un fichier texte (non binary) , j’ai décidé de fournir ma réponse.


Tout d’abord, Java 6 a généralement atteint la fin de sa vie, et comme l’auteur n’a pas précisé qu’il avait besoin d’une compatibilité héritée, cela signifie automatiquement Java 7 ou supérieur (Java 7 n’est pas encore fourni par IBM). Donc, nous pouvons regarder le didacticiel d’E / S de fichier: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Avant la version de Java SE 7, la classe java.io.File était le mécanisme utilisé pour les E / S de fichiers, mais elle présentait plusieurs inconvénients.

  • De nombreuses méthodes n’ont pas généré d’exceptions lorsqu’elles ont échoué. Il était donc impossible d’obtenir un message d’erreur utile. Par exemple, si une suppression de fichier échouait, le programme recevrait un “échec de suppression” mais ne saurait pas si c’était parce que le fichier n’existait pas, que l’utilisateur n’avait pas d’permissions ou qu’il y avait un autre problème.
  • La méthode de renommage ne fonctionnait pas de manière cohérente sur toutes les plates-formes.
  • Il n’y avait pas de réel soutien pour les liens symboliques.
  • Une prise en charge supplémentaire des métadonnées était souhaitée, telles que les permissions de fichier, le propriétaire du fichier et d’autres atsortingbuts de sécurité. L’access aux métadonnées des fichiers était inefficace.
  • Beaucoup de méthodes File ne sont pas adaptées. Demander une liste de répertoires volumineuse sur un serveur peut entraîner un blocage. Les répertoires volumineux peuvent également provoquer des problèmes de ressources mémoire, entraînant un déni de service.
  • Il n’était pas possible d’écrire du code fiable capable de parcourir récursivement une arborescence de fichiers et de répondre de manière appropriée s’il existait des liens symboliques circulaires.

Eh bien, cela exclut java.io.File. Si un fichier ne peut être écrit / ajouté, vous ne pourrez peut-être même pas savoir pourquoi.


Nous pouvons continuer à regarder le tutoriel: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Si vous avez toutes les lignes que vous écrirez (ajoutez) au fichier texte à l’avance , l’approche recommandée est https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html# write-java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption …-

Voici un exemple (simplifié):

 Path file = ...; List linesInMemory = ...; Files.write(file, linesInMemory, StandardCharsets.UTF_8); 

Un autre exemple (append):

 Path file = ...; List linesInMemory = ...; Files.write(file, linesInMemory, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE); 

Si vous voulez écrire le contenu du fichier comme vous allez : https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#newBufferedWriter-java.nio.file.Path-java .nio.charset.Charset-java.nio.file.OpenOption …-

Exemple simplifié (Java 8 ou plus):

 Path file = ...; try (BufferedWriter writer = Files.newBufferedWriter(file)) { writer.append("Zero header: ").append('0').write("\r\n"); [...] } 

Un autre exemple (append):

 Path file = ...; try (BufferedWriter writer = Files.newBufferedWriter(file, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE)) { writer.write("----------"); [...] } 

Ces méthodes nécessitent un minimum d’effort de la part de l’auteur et devraient être préférées à toutes les autres lors de l’écriture de fichiers [text].

Si pour une raison quelconque vous voulez séparer l’acte de création et d’écriture, l’équivalent Java du touch est

 try { //create a file named "testfile.txt" in the current working directory File myFile = new File("testfile.txt"); if ( myFile.createNewFile() ) { System.out.println("Success!"); } else { System.out.println("Failure!"); } } catch ( IOException ioe ) { ioe.printStackTrace(); } 

createNewFile() effectue une vérification de l’existence et crée un fichier de manière atomique. Cela peut être utile si vous souhaitez vous assurer d’être le créateur du fichier avant de lui écrire, par exemple.

Utilisation:

 JFileChooser c = new JFileChooser(); c.showOpenDialog(c); File writeFile = c.getSelectedFile(); Ssortingng content = "Input the data here to be written to your file"; try { FileWriter fw = new FileWriter(writeFile); BufferedWriter bw = new BufferedWriter(fw); bw.append(content); bw.append("hiiiii"); bw.close(); fw.close(); } catch (Exception exc) { System.out.println(exc); } 

Je pense que c’est le moyen le plus court:

 FileWriter fr = new FileWriter("your_file_name.txt"); // After '.' write // your file extention (".txt" in this case) fr.write("Things you want to write into the file"); // Warning: this will REPLACE your old file content! fr.close(); 

Pour créer un fichier sans écraser le fichier existant:

 System.out.println("Choose folder to create file"); JFileChooser c = new JFileChooser(); c.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY); c.showOpenDialog(c); c.getSelectedFile(); f = c.getSelectedFile(); // File f - global variable Ssortingng newfile = f + "\\hi.doc";//.txt or .doc or .html File file = new File(newfile); try { //System.out.println(f); boolean flag = file.createNewFile(); if(flag == true) { JOptionPane.showMessageDialog(rootPane, "File created successfully"); } else { JOptionPane.showMessageDialog(rootPane, "File already exists"); } /* Or use exists() function as follows: if(file.exists() == true) { JOptionPane.showMessageDialog(rootPane, "File already exists"); } else { JOptionPane.showMessageDialog(rootPane, "File created successfully"); } */ } catch(Exception e) { // Any exception handling method of your choice } 
 import java.io.File; import java.io.FileWriter; import java.io.IOException; public class FileWriterExample { public static void main(Ssortingng [] args) { FileWriter fw= null; File file =null; try { file=new File("WriteFile.txt"); if(!file.exists()) { file.createNewFile(); } fw = new FileWriter(file); fw.write("This is an ssortingng written to a file"); fw.flush(); fw.close(); System.out.println("File written Succesfully"); } catch (IOException e) { e.printStackTrace(); } } } 
 package fileoperations; import java.io.File; import java.io.IOException; public class SimpleFile { public static void main(Ssortingng[] args) throws IOException { File file =new File("text.txt"); file.createNewFile(); System.out.println("File is created"); FileWriter writer = new FileWriter(file); // Writes the content to the file writer.write("Enter the text that you want to write"); writer.flush(); writer.close(); System.out.println("Data is entered into file"); } } 

Une seule ligne! path et line sont des chaînes

 import java.nio.file.Files; import java.nio.file.Paths; Files.write(Paths.get(path), lines.getBytes()); 

La façon la plus simple de trouver:

 Path sampleOutputPath = Paths.get("/tmp/testfile") try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) { writer.write("Hello, world!"); } 

Cela ne fonctionnera probablement que pour les versions 1.7+.

Si nous utilisons Java 7 et supérieur et que nous connaissons également le contenu à append (ajouté) au fichier, nous pouvons utiliser la méthode newBufferedWriter dans le package NIO.

 public static void main(Ssortingng[] args) { Path FILE_PATH = Paths.get("C:/temp", "temp.txt"); Ssortingng text = "\n Welcome to Java 8"; //Writing to the file temp.txt try (BufferedWriter writer = Files.newBufferedWriter(FILE_PATH, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) { writer.write(text); } catch (IOException e) { e.printStackTrace(); } } 

Il y a peu de points à noter:

  1. C’est toujours une bonne habitude de spécifier le codage des jeux de caractères et pour cela nous avons une constante dans la classe StandardCharsets .
  2. Le code utilise l’instruction try-with-resource dans laquelle les ressources sont automatiquement fermées après l’essai.

Bien que OP n’ait pas demandé mais au cas où nous voudrions rechercher des lignes ayant un mot-clé spécifique, par exemple confidential nous pouvons utiliser des API de stream en Java:

 //Reading from the file the first line which contains word "confidential" try { Stream lines = Files.lines(FILE_PATH); Optional containsJava = lines.filter(l->l.contains("confidential")).findFirst(); if(containsJava.isPresent()){ System.out.println(containsJava.get()); } } catch (IOException e) { e.printStackTrace(); } 

Lecture et écriture de fichiers à l’aide d’entrées et de sorties:

 //Coded By Anurag Goel //Reading And Writing Files import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class WriteAFile { public static void main(Ssortingng args[]) { try { byte array [] = {'1','a','2','b','5'}; OutputStream os = new FileOutputStream("test.txt"); for(int x=0; x < array.length ; x++) { os.write( array[x] ); // Writes the bytes } os.close(); InputStream is = new FileInputStream("test.txt"); int size = is.available(); for(int i=0; i< size; i++) { System.out.print((char)is.read() + " "); } is.close(); } catch(IOException e) { System.out.print("Exception"); } } } 

Juste inclure ce paquet:

 java.nio.file 

Et puis vous pouvez utiliser ce code pour écrire le fichier:

 Path file = ...; byte[] buf = ...; Files.write(file, buf); 

Cela vaut la peine d’essayer Java 7+:

  Files.write(Paths.get("./output.txt"), "Information ssortingng herer".getBytes()); 

Ça a l’air prometteur …

Pour plusieurs fichiers, vous pouvez utiliser:

 static void out(Ssortingng[] name, Ssortingng[] content) { File path = new File(System.getProperty("user.dir") + File.separator + "OUT"); for (File file : path.listFiles()) if (!file.isDirectory()) file.delete(); path.mkdirs(); File c; for (int i = 0; i != name.length; i++) { c = new File(path + File.separator + name[i] + ".txt"); try { c.createNewFile(); FileWriter fiWi = new FileWriter(c.getAbsoluteFile()); BufferedWriter buWi = new BufferedWriter(fiWi); buWi.write(content[i]); buWi.close(); } catch (IOException e) { e.printStackTrace(); } } } 

Ça marche très bien.

Voici quelques façons possibles de créer et d’écrire un fichier en Java:

Utiliser FileOutputStream

 try { File fout = new File("myOutFile.txt"); FileOutputStream fos = new FileOutputStream(fout); BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos)); bw.write("Write somthing to the file ..."); bw.newLine(); bw.close(); } catch (FileNotFoundException e){ // File was not found e.printStackTrace(); } catch (IOException e) { // Problem when writing to the file e.printStackTrace(); } 

Utiliser FileWriter

 try { FileWriter fw = new FileWriter("myOutFile.txt"); fw.write("Example of content"); fw.close(); } catch (FileNotFoundException e) { // File not found e.printStackTrace(); } catch (IOException e) { // Error when writing to the file e.printStackTrace(); } 

Utiliser PrintWriter

 try { PrintWriter pw = new PrintWriter("myOutFile.txt"); pw.write("Example of content"); pw.close(); } catch (FileNotFoundException e) { // File not found e.printStackTrace(); } catch (IOException e) { // Error when writing to the file e.printStackTrace(); } 

Utiliser OutputStreamWriter

 try { File fout = new File("myOutFile.txt"); FileOutputStream fos = new FileOutputStream(fout); OutputStreamWriter osw = new OutputStreamWriter(fos); osw.write("Soe content ..."); osw.close(); } catch (FileNotFoundException e) { // File not found e.printStackTrace(); } catch (IOException e) { // Error when writing to the file e.printStackTrace(); } 

Pour plus d’informations, consultez ce tutoriel sur Comment lire et écrire des fichiers en Java .

Il existe des moyens simples, comme:

 File file = new File("filename.txt"); PrintWriter pw = new PrintWriter(file); pw.write("The world I'm coming"); pw.close(); Ssortingng write = "Hello World!"; FileWriter fw = new FileWriter(file); BufferedWriter bw = new BufferedWriter(fw); fw.write(write); fw.close(); 

Vous pouvez même créer un fichier temporaire en utilisant une propriété système , qui sera indépendante du système d’exploitation que vous utilisez.

 File file = new File(System.*getProperty*("java.io.tmpdir") + System.*getProperty*("file.separator") + "YourFileName.txt"); 

Grâce à la bibliothèque Guava de Google, nous pouvons créer et écrire dans un fichier très facilement.

 package com.zetcode.writetofileex; import com.google.common.io.Files; import java.io.File; import java.io.IOException; public class WriteToFileEx { public static void main(Ssortingng[] args) throws IOException { Ssortingng fileName = "fruits.txt"; File file = new File(fileName); Ssortingng content = "banana, orange, lemon, apple, plum"; Files.write(content.getBytes(), file); } } 

L’exemple crée un nouveau fichier fruits.txt dans le répertoire racine du projet.

Lecture de la collection avec les clients et enregistrement dans un fichier, avec JFilechooser.

 private void writeFile(){ JFileChooser fileChooser = new JFileChooser(this.PATH); int retValue = fileChooser.showDialog(this, "Save File"); if (retValue == JFileChooser.APPROVE_OPTION){ try (Writer fileWrite = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileChooser.getSelectedFile())))){ this.customers.forEach((c) ->{ try{ fileWrite.append(c.toSsortingng()).append("\n"); } catch (IOException ex){ ex.printStackTrace(); } }); } catch (IOException e){ e.printStackTrace(); } } } 

le meilleur moyen est d’utiliser Java7: Java 7 introduit une nouvelle façon de travailler avec le système de fichiers, ainsi qu’une nouvelle classe d’utilitaires – Fichiers. En utilisant la classe Files, nous pouvons créer, déplacer, copier, supprimer des fichiers et des répertoires également; il peut également être utilisé pour lire et écrire dans un fichier.

 public void saveDataInFile(Ssortingng data) throws IOException { Path path = Paths.get(fileName); byte[] strToBytes = data.getBytes(); Files.write(path, strToBytes); } 

Ecrire avec FileChannel Si vous traitez des fichiers volumineux, FileChannel peut être plus rapide que les E / S standard. Le code suivant écrit Ssortingng dans un fichier à l’aide de FileChannel:

 public void saveDataInFile(Ssortingng data) throws IOException { RandomAccessFile stream = new RandomAccessFile(fileName, "rw"); FileChannel channel = stream.getChannel(); byte[] strBytes = data.getBytes(); ByteBuffer buffer = ByteBuffer.allocate(strBytes.length); buffer.put(strBytes); buffer.flip(); channel.write(buffer); stream.close(); channel.close(); } 

Ecrire avec DataOutputStream

 public void saveDataInFile(Ssortingng data) throws IOException { FileOutputStream fos = new FileOutputStream(fileName); DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(fos)); outStream.writeUTF(data); outStream.close(); } 

Ecrire avec FileOutputStream

Voyons maintenant comment utiliser FileOutputStream pour écrire des données binarys dans un fichier. Le code suivant convertit un octet Ssortingng int et écrit les octets dans un fichier à l’aide d’un fichier FileOutputStream:

 public void saveDataInFile(Ssortingng data) throws IOException { FileOutputStream outputStream = new FileOutputStream(fileName); byte[] strToBytes = data.getBytes(); outputStream.write(strToBytes); outputStream.close(); } 

Écrivez avec PrintWriter nous pouvons utiliser un PrintWriter pour écrire du texte formaté dans un fichier:

 public void saveDataInFile() throws IOException { FileWriter fileWriter = new FileWriter(fileName); PrintWriter printWriter = new PrintWriter(fileWriter); printWriter.print("Some Ssortingng"); printWriter.printf("Product name is %s and its price is %d $", "iPhone", 1000); printWriter.close(); } 

Écrivez avec BufferedWriter: utilisez BufferedWriter pour écrire une chaîne dans un nouveau fichier:

 public void saveDataInFile(Ssortingng data) throws IOException { BufferedWriter writer = new BufferedWriter(new FileWriter(fileName)); writer.write(data); writer.close(); } 

append une chaîne au fichier existant:

 public void saveDataInFile(Ssortingng data) throws IOException { BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true)); writer.append(' '); writer.append(data); writer.close(); } 

Dans Java 8, utilisez Files and Paths et utilisez la construction try-with-resources.

 import java.io.BufferedWriter; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; public class WriteFile{ public static void main(Ssortingng[] args) throws IOException { Ssortingng file = "text.txt"; System.out.println("Writing to file: " + file); // Files.newBufferedWriter() uses UTF-8 encoding by default try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(file))) { writer.write("Java\n"); writer.write("Python\n"); writer.write("Clojure\n"); writer.write("Scala\n"); writer.write("JavaScript\n"); } // the file will be automatically closed } }