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 IOException. Les blocs try / catch / finally ont été omis par souci de concision. Consultez ce didacticiel 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éation d'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 Filesclasse 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éation d'un fichier binaire:

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

En Java 7 et supérieur:

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
• Files.write (..) de goyave

Notez également que vous pouvez utiliser a 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 explicitement l'encodage.

Vous trouverez ci-dessous 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), l' java.nio.file.Filesajout dans Java 7 dans le cadre des E / S natives fournit le moyen le plus simple et le plus efficace pour atteindre vos objectifs.

Fondamentalement, la création et l'écriture dans un fichier se fait sur une seule ligne, en plus 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 donc elle peut ê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();
    }
}

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

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 try()fermera automatiquement le flux. Cette version est courte, rapide (tamponnée) et permet de choisir l'encodage.

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

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.

É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 (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 précisé qu'il s'agit d'un fichier texte (non binaire) , j'ai décidé d'apporter 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 a besoin d'une compatibilité héritée, je suppose que cela signifie automatiquement Java 7 ou supérieur (Java 7 n'est pas encore en fin de vie par IBM). Ainsi, nous pouvons regarder à droite le didacticiel d'E / S de 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 de fichiers, mais elle présentait plusieurs inconvénients.

• De nombreuses méthodes ne lançaient pas d'exceptions en cas d'échec, 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, l'utilisateur n'avait pas les autorisations ou il y avait un autre problème.
• La méthode de renommage ne fonctionnait pas de manière cohérente sur toutes les plateformes.
• Il n'y avait pas vraiment de support pour les liens symboliques.
• Une meilleure prise en charge des métadonnées était souhaitée, comme les autorisations de fichier, le propriétaire du fichier et d'autres attributs de sécurité. L'accès aux métadonnées des fichiers était inefficace.
• De nombreuses méthodes de fichier n'ont pas évolué. La demande d'une grande liste de répertoires 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 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.

Eh bien, cela exclut java.io.File. Si un fichier ne peut pas ê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 (ajouterez) 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 (en 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 du 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.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 (en 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 effort minimal 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 indolore, vous pouvez également consulter le package Apache Commons IO , plus précisément la FileUtilsclasse .

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

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

Si pour une raison quelconque vous voulez séparer l'acte de créer et d'écrire, l'équivalent Java de touchest

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()vérifie l'existence et crée un fichier de manière atomique. Cela peut être utile si vous voulez vous assurer que vous avez été le créateur du fichier avant d'y écrire, par exemple.

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 d'informations, consultez ce didacticiel sur la lecture et l'écriture de fichiers en Java .

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

la meilleure façon 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 - Files. 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 traitez de gros fichiers, FileChannel peut être plus rapide que les E / S 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 une chaîne en octets 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();
}

É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 String");
    printWriter.printf("Product name is %s and its price is %d $", "iPhone", 1000);
    printWriter.close();
}

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

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

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

Une seule ligne! pathet linesont des cordes

import java.nio.file.Files;
import java.nio.file.Paths;

Files.write(Paths.get(path), lines.getBytes());

La façon la 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+.

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

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

Cela semble prometteur ...

Si nous utilisons Java 7 et supérieur et 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 quelques points à noter:

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

Bien que OP ne l'ait pas demandé, mais juste au cas où nous souhaiterions rechercher des lignes ayant un mot clé spécifique, par exemple, confidentialnous pouvons utiliser des 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 le flux d'entrée et de sortie:

//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 package:

java.nio.file

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

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

En Java 8, utilisez Fichiers et 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
    }
}

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 à l'aide d'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 Google 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 fruits.txtfichier 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();
        }
    }
}

Il existe au moins plusieurs façons de créer un fichier et d'y écrire:

Petits fichiers (1.7)

Vous pouvez utiliser l'une des méthodes d'écriture pour écrire des octets ou des lignes dans un fichier.

Path file = Paths.get("path-to-file");
byte[] buf = "text-to-write-to-file".;
Files.write(file, buf);

Ces méthodes prennent en charge la plupart du travail pour vous, telles que l'ouverture et la fermeture du flux, mais ne sont pas destinées à gérer des fichiers volumineux.

Écriture d'un fichier plus volumineux à l'aide d'E / S de flux mis en mémoire tampon (1.7)

Le java.nio.filepackage prend en charge les E / S de canal, qui déplacent les données dans des tampons, contournant certaines des couches qui peuvent goulot d'étranglement des E / S de flux.

String s = "much-larger-text-to-write-to-file";
try (BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
    writer.write(s, 0, s.length());
}

Cette approche est préférentielle en raison de ses performances efficaces, en particulier lors de l'achèvement d'un grand nombre d'opérations d'écriture. Les opérations tamponnées ont cet effet car elles ne sont pas obligées d'appeler la méthode d'écriture du système d'exploitation pour chaque octet, ce qui réduit les opérations d'E / S coûteuses.

Utilisation de l'API NIO pour copier (et en créer un nouveau) un fichier avec un flux de sortie (1.7)

Path oldFile = Paths.get("existing-file-path");
Path newFile = Paths.get("new-file-path");
try (OutputStream os = new FileOutputStream(newFile.toFile())) {
    Files.copy(oldFile, os);
}

Il existe également des méthodes supplémentaires qui permettent de copier tous les octets d'un flux d'entrée dans un fichier.

FileWriter (texte) (<1.7)

Écrit directement dans le fichier (moins de performances) et ne doit être utilisé que lorsque le nombre d'écritures est inférieur. Utilisé pour écrire des données orientées caractères dans un fichier.

String s= "some-text";
FileWriter fileWriter = new FileWriter("C:\\path\\to\\file\\file.txt");
fileWriter.write(fileContent);
fileWriter.close();

FileOutputStream (binaire) (<1.7)

FileOutputStream est destiné à l'écriture de flux d'octets bruts tels que des données d'image.

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

Avec cette approche, il faut envisager de toujours écrire un tableau d'octets plutôt que d'écrire un octet à la fois. L'accélération peut être assez importante - jusqu'à 10 fois plus ou plus. Par conséquent, il est recommandé d'utiliser les write(byte[])méthodes autant que possible.