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

Dans 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 pour cela:

• FileUtils.writeStringtoFile(..) de commons-io
• Fichiers.écrire(..) de la goyave

Notez également que vous peut utiliser FileWriter, mais il utilise l'encodage par défaut, ce qui est souvent une mauvaise idée - il est préférable de spécifier l'encodage explicite.

Ci-dessous est la réponse originale, 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 l'ajout dans Java 7 dans le cadre des E/S natives fournit le moyen le plus simple et le plus efficace d'atteindre vos objectifs.

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

L'exemple suivant crée et écrit à 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 afin qu'elle puisse être comprise 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
}  

L'utilisation de try() fermera automatiquement le flux. 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(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);
        }
    }
}

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

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.

Si vous souhaitez avoir une expérience relativement sans douleur, vous pouvez également jeter un œil au paquet Apache Commons IO , plus précisément le FileUtils classe .

N'oubliez jamais de vérifier les bibliothèques tierces. Joda-Time pour la manipulation de date, Apache Commons Lang StringUtils pour les opérations de chaîne courantes et telles peuvent rendre votre code plus lisible.

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

Étant donné que l'auteur n'a pas précisé s'ils ont besoin d'une solution pour les versions Java qui ont été Eol'd (par Sun et IBM, et ce sont techniquement les JVM les plus répandues), et en raison du fait que la plupart des gens semblent avoir répondu à la question de l'auteur avant qu'il ne soit spécifié qu'il s'agit d'un fichiertexte (non binaire) , j'ai décidé de fournir ma réponse.

Tout d'abord, Java 6 a généralement atteint la fin de vie, et puisque l'auteur n'a pas précisé qu'il avait besoin compatibilité héritée, je suppose que cela signifie automatiquement Java 7 ou supérieur (Java 7 n'est pas encore Eol'd par IBM). Nous pouvons donc regarder le tutoriel d'E/S de fichier: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Avant la version Java SE 7, la classe java. io. File était la mécanisme utilisé pour les E/S de fichier, mais il avait plusieurs inconvénients.

• De nombreuses méthodes n'ont pas levé d'exceptions lorsqu'elles ont échoué, donc c'était impossible d'obtenir une erreur utile message. Par exemple, si un fichier la suppression a échoué, le programme recevrait un" échec de suppression " mais je ne saurais pas si c'était parce que le fichier n'existait pas, l'utilisateur ne l'a pas fait ont des autorisations, ou il y avait un autre problème.
• La méthode rename ne fonctionnait pas de manière cohérente sur toutes les plateformes.
• Il n'y avait pas de soutien réel pour les liens symboliques.
• Une prise en charge accrue des métadonnées était souhaitée, par exemple autorisations de fichier, propriétaire de fichier et autres attributs de sécurité. Accéder les métadonnées des fichiers étaient inefficaces.
• La plupart des méthodes de fichiers n'ont pas évolué. Demander une liste de répertoires volumineux sur un serveur peut entraîner accrocher. Les grands répertoires peuvent également causer des problèmes de ressources en mémoire, avec pour conséquence un déni de service.
• , Il n'était pas possible d'écrire code fiable qui pourrait parcourir récursivement une arborescence de fichiers et répondre de manière appropriée s'il y avait des liens symboliques circulaires.

Oh eh bien, cela exclut java. io. File. If a le fichier ne peut pas être écrite/ajouté, vous ne pourrez peut-être même 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 allez écrire (ajouter) pour le fichier texte à l'avance, l'approche recommandée être 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 (ajouter):

Path file = ...;
List<String> 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 aller: 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 supérieur):

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

Un autre exemple (ajouter):

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 effort minimal de la part de l'auteur et devraient être préférées à toutes les autres lors de l'écriture dans des fichiers [texte].

Si vous voulez séparer l'acte de la création et de l'écriture, Java équivalent 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() est-ce qu'une vérification d'existence et un fichier créent atomiquement. Cela peut être utile si vous voulez vous assurer que vous étiez le créateur du fichier, avant d'é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 chemin 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 un 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");
    }
}

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+.

Si nous utilisons Java 7 et plus 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:

1. C'est toujours une bonne habitude de spécifier l'encodage du jeu 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 juste au cas où nous voulons 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();
}

Lecture et écriture de fichiers en utilisant input et outputstream:

//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");
        }
    }
}

Il suffit d'inclure ce paquet:

java.nio.file

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

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

Cela vaut la peine d'essayer pour Java 7+:

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

Cela semble prometteur...

Pour plusieurs fichiers, vous pouvez utiliser:

static void out(String[] name, String[] 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-unes des façons possibles de créer et d'écrire un fichier en 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 plus de détails, consultez ce tutoriel sur la façon de 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();

String 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");

En utilisant la bibliothèque Goyave 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(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 fruits.txt fichier 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.toString()).append("\n");
                }
                catch (IOException ex){
                    ex.printStackTrace();
                }
            });
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
}

La Meilleure façon est d'utiliser des Java7: Java 7 introduit une nouvelle façon de travailler avec le système de fichiers, avec une nouvelle classe utilitaire Fichiers. En utilisant la classe Files, nous pouvons également 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);
}

Écrire avec FileChannel Si vous avez affaire à des fichiers volumineux, FileChannel peut être plus rapide que les E / S standard. Le code suivant écrit une chaîne dans un fichier en utilisant 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 nous pouvons utiliser FileOutputStream pour écrire des données binaires dans un fichier. Le code suivant convertit une chaîne int octets 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();
}

Écrire 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();
}

Écrire avec BufferedWriter: utiliser 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();
}

En Java 8, utilisez des fichiers et des chemins 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(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
    }
}