Comment créer un fichier et y écrire en Java?
Quel est le moyen le plus simple de créer et d'écrire dans un fichier (texte) en Java?
Notez que chacun des exemples de code ci-dessous peut générer IOException. Les blocs try/catch/finally ont été omis pour des raisons de brièveté. Voir ce tutoriel pour plus d'informations sur la gestion des exceptions.
Notez que chacun des exemples de code ci-dessous écrasera le fichier s'il existe déjà .
Création d'un fichier texte:
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 binaire:
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éation d'un fichier texte:
List<String> lines = Arrays.asList("The first line", "The second line");
Path file = Paths.get("the-file-name.txt");
Files.write(file, lines, StandardCharsets.UTF_8);
//Files.write(file, lines, StandardCharsets.UTF_8, StandardOpenOption.APPEND);
Créer un fichier binaire:
byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);
Dans Java 7 et versions ultérieures:
try (Writer writer = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream("filename.txt"), "utf-8"))) {
writer.write("something");
}
Il existe des utilitaires utiles pour cela cependant:
- FileUtils.writeStringtoFile (..) à partir 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 le encodage explicitement.
Vous trouverez ci-dessous la réponse d'origine, antérieure à 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), le Java.nio.file.Files addition dans Java 7 dans le cadre de la version native I/O constitue le moyen le plus simple et le plus efficace d’atteindre vos objectifs.
Fondamentalement, créer et écrire dans un fichier ne représente qu'une ligne, en outre 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<String> 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(String[] args) {
String 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 pour que cela soit compris 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(String[]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 automatiquement le flux. Cette version est courte, rapide (mise en mémoire tampon) et permet de choisir le codage.
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(String[] args) {
try{
// Create new file
String content = "This is the content to write into create file";
String 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);
}
}
}
Ici, nous entrons une chaîne dans un fichier texte:
String 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 ajouter du contenu.
Comme l’auteur n’a pas précisé s’il fallait une solution pour Java versions EoL'd (de Sun et d’IBM, et il s’agit des machines virtuelles les plus répandues), et du fait que la plupart des les gens semblent avoir répondu à la question de l'auteur avant qu'il ne soit spécifié qu'il s'agit d'un fichier texte (non binaire) , j'ai décidé de fournir ma réponse.
Tout d’abord, Java 6 est généralement en fin de vie et, l’auteur ne spécifiant pas qu'il a besoin d’une compatibilité héritée, j’imagine que cela signifie automatiquement Java 7 ou une version ultérieure (Java 7 n’est pas encore EoL'd par IBM). Nous pouvons donc regarder le didacticiel d’E/S sur les fichiers: https://docs.Oracle.com/javase/tutorial/essential/io/legacy.html
Avant la version Java SE 7, la classe Java.io.File était le mécanisme utilisé pour les E/S sur les fichiers, mais elle présentait plusieurs inconvénients.
- De nombreuses méthodes ne lançaient pas d'exceptions lorsqu'elles échouaient. 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 savait pas si c'était parce que le fichier n'existait pas, si l'utilisateur n'avait pas les autorisations ou s'il existait un autre problème.
- La méthode de changement de nom n'a pas fonctionné de manière uniforme sur toutes les plateformes.
- Il n'y avait pas de réel soutien pour les liens symboliques.
- Une plus grande prise en charge des métadonnées était souhaitée, telle que les autorisations de fichier, le propriétaire du fichier et d'autres attributs de sécurité. L'accès aux métadonnées de fichier était inefficace.
- Beaucoup de méthodes File n'ont pas été mises à l'échelle. Demander une liste de répertoires volumineuse sur un serveur peut entraîner un blocage. Les grands annuaires peuvent également causer des problèmes de ressources de mémoire, entraînant un déni de service.
- Il n’était pas possible d’écrire un code fiable capable de parcourir récursivement une arborescence de fichiers et de réagir de manière appropriée s’il existait des liens symboliques circulaires.
Eh bien, cela exclut Java.io.File. Si un fichier ne peut pas être écrit/ajouté, vous ne pourrez 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 à écrire (ajouter) 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<String> linesInMemory = ...;
Files.write(file, linesInMemory, StandardCharsets.UTF_8);
Un autre exemple (annexe):
Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE);
Si vous souhaitez écrire le contenu d'un fichier au fur et à mesure : https://docs.Oracle.com/javase/8/docs/api /Java/nio/file/Files.html#newBufferedWriter-Java.nio.file.Path-Java.nio.charset-Java.nio.file.OpenOption...-
Exemple simplifié (Java 8 ou supérieur):
Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file)) {
writer.append("Zero header: ").append('0').write("\r\n");
[...]
}
Un autre exemple (annexe):
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 doivent être préférées à toutes les autres lors de l'écriture dans des fichiers [texte].
Si vous souhaitez vivre une expérience relativement sans douleur, vous pouvez également consulter le package Apache Commons IO , plus précisément. la FileUtils class .
N'oubliez jamais de vérifier les bibliothèques tierces. Joda-Time pour la manipulation de la date, Apache Commons Lang StringUtils pour les opérations courantes sur les chaînes et autres peuvent rendre votre code plus lisible.
Java est un bon langage, mais la bibliothèque standard est parfois un peu bas niveau. Puissant, mais bas niveau néanmoins.
Voici quelques manières possibles de créer et d'écrire un fichier dans Java:
Utilisation de 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();
}
Utilisation de 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();
}
Utilisation de 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();
}
Utilisation de 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 en savoir plus, consultez ce didacticiel sur Comment lire et écrire des fichiers en Java .
Si, pour une raison quelconque, vous souhaitez séparer l'acte de créer et d'écrire, l'équivalent Java de 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 voulez vous assurer que vous êtes le créateur du fichier avant de l'écrire, par exemple.
Utilisation:
JFileChooser c = new JFileChooser();
c.showOpenDialog(c);
File writeFile = c.getSelectedFile();
String 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();
Le meilleur moyen consiste à utiliser Java7: Java 7 introduit une nouvelle façon de travailler avec le système de fichiers, ainsi qu’une nouvelle classe d’utilitaire - Fichiers. En utilisant la classe Files, nous pouvons créer, déplacer, copier, supprimer des fichiers et des répertoires; il peut également être utilisé pour lire et écrire dans un fichier.
public void saveDataInFile(String data) throws IOException {
Path path = Paths.get(fileName);
byte[] strToBytes = data.getBytes();
Files.write(path, strToBytes);
}
Ecrire avec FileChannel Si vous traitez avec des fichiers volumineux, FileChannel peut être plus rapide que l'IO standard. Le code suivant écrit String dans un fichier à l'aide de FileChannel:
public void saveDataInFile(String 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();
}
écrire avec DataOutputStream
public void saveDataInFile(String data) throws IOException {
FileOutputStream fos = new FileOutputStream(fileName);
DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(fos));
outStream.writeUTF(data);
outStream.close();
}
écrire avec FileOutputStream
Voyons maintenant comment utiliser FileOutputStream pour écrire des données binaires dans un fichier. Le code suivant convertit un octet String int et écrit les octets dans un fichier à l'aide d'un FileOutputStream:
public void saveDataInFile(String data) throws IOException {
FileOutputStream outputStream = new FileOutputStream(fileName);
byte[] strToBytes = data.getBytes();
outputStream.write(strToBytes);
outputStream.close();
}
Ecrire 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 String");
printWriter.printf("Product name is %s and its price is %d $", "iPhone", 1000);
printWriter.close();
}
Write with BufferedWriter: utilisez BufferedWriter pour écrire une chaîne dans un nouveau fichier:
public void saveDataInFile(String data) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
writer.write(data);
writer.close();
}
ajouter une chaîne au fichier existant:
public void saveDataInFile(String data) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
writer.append(' ');
writer.append(data);
writer.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
String 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(String [] 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 string 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(String[] 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");
}
}
Cela vaut la peine d'essayer pour Java 7+:
Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());
Cela semble prometteur ...
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());
Le moyen le plus simple que je puisse trouver:
Path sampleOutputPath = Paths.get("/tmp/testfile")
try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
writer.write("Hello, world!");
}
Cela ne fonctionnera probablement que pour 1.7+.
Dans Java 8, utilisez Fichiers et chemins et utilisez la structure 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(String[] args) throws IOException {
String 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
}
}
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(String 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");
}
}
}
Incluez simplement ce forfait:
Java.nio.file
Et ensuite, vous pouvez utiliser ce code pour écrire le fichier:
Path file = ...;
byte[] buf = ...;
Files.write(file, buf);
Si nous utilisons Java 7 et versions ultérieures et que nous connaissons également le contenu à ajouter (ajouté) au fichier, nous pouvons utiliser la méthode newBufferedWriter dans le package NIO.
public static void main(String[] args) {
Path FILE_PATH = Paths.get("C:/temp", "temp.txt");
String 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:
- C'est toujours une bonne habitude de spécifier l'encodage de charset et pour cela nous avons constant dans la classe
StandardCharsets. - Le code utilise l'instruction
try-with-resourcedans laquelle les ressources sont automatiquement fermées après l'essai.
Bien que OP n'ait pas demandé, mais juste au cas où nous voudrions rechercher des lignes ayant un mot clé spécifique, par exemple. confidential nous pouvons utiliser les API de flux en Java:
//Reading from the file the first line which contains Word "confidential"
try {
Stream<String> lines = Files.lines(FILE_PATH);
Optional<String> containsJava = lines.filter(l->l.contains("confidential")).findFirst();
if(containsJava.isPresent()){
System.out.println(containsJava.get());
}
} catch (IOException e) {
e.printStackTrace();
}
Vous pouvez même créer un fichier temporaire en utilisant un propriété système, qui sera indépendant du système d'exploitation que vous utilisez.
File file = new File(System.*getProperty*("Java.io.tmpdir") +
System.*getProperty*("file.separator") +
"YourFileName.txt");
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();
String write = "Hello World!";
FileWriter fw = new FileWriter(file);
BufferedWriter bw = new BufferedWriter(fw);
fw.write(write);
fw.close();
Lecture de la collection avec les clients et sauvegarde 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.toString()).append("\n");
}
catch (IOException ex){
ex.printStackTrace();
}
});
}
catch (IOException e){
e.printStackTrace();
}
}
}
En utilisant la bibliothèque Google de guava, 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(String[] args) throws IOException {
String fileName = "fruits.txt";
File file = new File(fileName);
String 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.
Création d'un exemple de fichier:
try {
File file = new File ("c:/new-file.txt");
if(file.createNewFile()) {
System.out.println("Successful created!");
}
else {
System.out.println("Failed to create!");
}
}
catch (IOException e) {
e.printStackTrace();
}