Comment ajouter du texte à un fichier existant en Java ?

Question

J'ai besoin d'ajouter du texte de façon répétée à un fichier existant en Java. Comment faire ?

Answer 1

Faites-vous cela à des fins de journalisation ? Si c'est le cas, il existe plusieurs bibliothèques pour cela . Deux des plus populaires sont Log4j y Retour à la case départ .

Java 7+

Pour une tâche ponctuelle, le Classe de fichiers facilite les choses :

try {
    Files.write(Paths.get("myfile.txt"), "the text".getBytes(), StandardOpenOption.APPEND);
}catch (IOException e) {
    //exception handling left as an exercise for the reader
}

Attention : L'approche ci-dessus génère un NoSuchFileException si le fichier n'existe pas encore. Il n'ajoute pas non plus de nouvelle ligne automatiquement (ce que vous souhaitez souvent lors de l'ajout d'un fichier texte). Une autre approche consiste à passer les deux commandes CREATE y APPEND qui crée d'abord le fichier s'il n'existe pas déjà :

private void write(final String s) throws IOException {
    Files.writeString(
        Path.of(System.getProperty("java.io.tmpdir"), "filename.txt"),
        s + System.lineSeparator(),
        CREATE, APPEND
    );
}

Toutefois, si vous écrivez plusieurs fois dans le même fichier, les extraits ci-dessus doivent ouvrir et fermer le fichier sur le disque plusieurs fois, ce qui est une opération lente. Dans ce cas, un BufferedWriter est plus rapide :

try(FileWriter fw = new FileWriter("myfile.txt", true);
    BufferedWriter bw = new BufferedWriter(fw);
    PrintWriter out = new PrintWriter(bw))
{
    out.println("the text");
    //more code
    out.println("more text");
    //more code
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}

Notes :

• Le deuxième paramètre de la fonction FileWriter lui indiquera d'ajouter au fichier, plutôt que d'écrire un nouveau fichier. (Si le fichier n'existe pas, il sera créé).
• L'utilisation d'un BufferedWriter est recommandé pour un écrivain coûteux (tel que FileWriter ).
• L'utilisation d'un PrintWriter vous donne accès à println que vous avez probablement l'habitude d'utiliser dans le cadre du programme System.out .
• Mais le BufferedWriter y PrintWriter ne sont pas strictement nécessaires.

---

Ancienne Java

try {
    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("myfile.txt", true)));
    out.println("the text");
    out.close();
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}

---

Traitement des exceptions

Si vous avez besoin d'une gestion robuste des exceptions pour les anciennes versions de Java, cela devient très verbeux :

FileWriter fw = null;
BufferedWriter bw = null;
PrintWriter out = null;
try {
    fw = new FileWriter("myfile.txt", true);
    bw = new BufferedWriter(fw);
    out = new PrintWriter(bw);
    out.println("the text");
    out.close();
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}
finally {
    try {
        if(out != null)
            out.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
    try {
        if(bw != null)
            bw.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
    try {
        if(fw != null)
            fw.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
}

Answer 2

Vous pouvez utiliser fileWriter avec un drapeau fixé à true pour l'annexer.

try
{
    String filename= "MyFile.txt";
    FileWriter fw = new FileWriter(filename,true); //the true will append the new data
    fw.write("add a line\n");//appends the string to the file
    fw.close();
}
catch(IOException ioe)
{
    System.err.println("IOException: " + ioe.getMessage());
}

Answer 3

Toutes les réponses ici avec des blocs try/catch ne devraient-elles pas contenir les éléments .close() dans un bloc finally ?

Exemple de réponse corrigée :

PrintWriter out = null;
try {
    out = new PrintWriter(new BufferedWriter(new FileWriter("writePath", true)));
    out.println("the text");
} catch (IOException e) {
    System.err.println(e);
} finally {
    if (out != null) {
        out.close();
    }
} 

En outre, depuis Java 7, vous pouvez utiliser un fichier Déclaration sur l'utilisation des ressources . Aucun bloc final n'est nécessaire pour fermer la (les) ressource(s) déclarée(s), car cette opération est gérée automatiquement et est également moins verbeuse :

try(PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("writePath", true)))) {
    out.println("the text");
} catch (IOException e) {
    System.err.println(e);
}

Answer 4

Utilisation d'Apache Commons 2.1 :

import org.apache.logging.log4j.core.util.FileUtils;

FileUtils.writeStringToFile(file, "String to append", true);

Answer 5

Veillez à ce que le flux soit correctement fermé dans tous les cas de figure.

Il est un peu alarmant de constater le nombre de réponses qui laissent la poignée du fichier ouverte en cas d'erreur. La réponse https://stackoverflow.com/a/15053443/2498188 est dans le mille, mais seulement parce que BufferedWriter() ne peut pas lancer. Si c'était le cas, une exception quitterait le FileWriter objet ouvert.

Une façon plus générale de procéder qui ne se préoccupe pas de savoir si BufferedWriter() peut lancer :

  PrintWriter out = null;
  BufferedWriter bw = null;
  FileWriter fw = null;
  try{
     fw = new FileWriter("outfilename", true);
     bw = new BufferedWriter(fw);
     out = new PrintWriter(bw);
     out.println("the text");
  }
  catch( IOException e ){
     // File writing/opening failed at some stage.
  }
  finally{
     try{
        if( out != null ){
           out.close(); // Will close bw and fw too
        }
        else if( bw != null ){
           bw.close(); // Will close fw too
        }
        else if( fw != null ){
           fw.close();
        }
        else{
           // Oh boy did it fail hard! :3
        }
     }
     catch( IOException e ){
        // Closing the file writers failed for some obscure reason
     }
  }

Edita:

Depuis Java 7, il est recommandé d'utiliser "try with resources" et de laisser la JVM s'en charger :

  try(    FileWriter fw = new FileWriter("outfilename", true);
          BufferedWriter bw = new BufferedWriter(fw);
          PrintWriter out = new PrintWriter(bw)){
     out.println("the text");
  }  
  catch( IOException e ){
      // File writing/opening failed at some stage.
  }