Question Comment ajouter du texte à un fichier existant en Java


J'ai besoin d'ajouter du texte à plusieurs reprises à un fichier existant en Java. Comment je fais ça?


583
2017-10-26 14:43


origine


Réponses:


Faites-vous cela à des fins de journalisation? Si oui, il y a plusieurs bibliothèques pour cela. Deux des plus populaires sont Log4j et Logback.

Java 7+

Si vous avez juste besoin de faire ceci une fois, le Classe de fichiers cela rend cela facile

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

Prudent: L'approche ci-dessus va jeter un NoSuchFileException si le fichier n'existe pas déjà. Il n'ajoute pas automatiquement de nouvelle ligne (ce que vous voulez souvent lors de l'ajout à un fichier texte). La réponse de Steve Chambers couvre comment vous pourriez le faire avec Files classe.

Cependant, si vous écrivez plusieurs fois dans le même fichier, vous devez ouvrir et fermer plusieurs fois le fichier sur le disque, ce qui est une opération lente. Dans ce cas, un écrivain tamponné est meilleur:

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
}

Remarques:

  • Le deuxième paramètre à la FileWriter constructeur lui dira d'ajouter au fichier, plutôt que d'écrire un nouveau fichier. (Si le fichier n'existe pas, il sera créé.)
  • Utilisant un BufferedWriter est recommandé pour un écrivain cher (comme FileWriter).
  • Utilisant un PrintWriter vous donne accès à println la syntaxe que vous êtes probablement habitué à partir de System.out.
  • Mais le BufferedWriter et PrintWriter les emballages ne sont pas strictement nécessaires.

Java ancien

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
}

Gestion des exceptions

Si vous avez besoin d'une gestion robuste des exceptions pour Java plus ancien, il 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
    }
}

668
2017-10-26 14:47



Vous pouvez utiliser fileWriter avec un drapeau mis à true , pour l'ajout.

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

151
2017-10-26 14:48



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

Exemple de réponse marqué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();
    }
} 

Aussi, à partir de Java 7, vous pouvez utiliser un instruction try-with-resources. Aucun bloc finally n'est requis pour fermer la / les ressource (s) déclarée (s) car il est géré automatiquement, et est également moins verbeux:

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

64
2018-02-24 15:48



modifier - à partir d'Apache Commons 2.1, la bonne façon de procéder est la suivante:

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

J'ai adapté la solution de @ Kip pour inclure correctement la fermeture du fichier sur:

public static void appendToFile(String targetFile, String s) throws IOException {
    appendToFile(new File(targetFile), s);
}

public static void appendToFile(File targetFile, String s) throws IOException {
    PrintWriter out = null;
    try {
        out = new PrintWriter(new BufferedWriter(new FileWriter(targetFile, true)));
        out.println(s);
    } finally {
        if (out != null) {
            out.close();
        }
    }
}


39
2017-12-03 13:41



Assurez-vous que le flux est correctement fermé dans tous les scénarios.

C'est un peu alarmant combien de ces réponses laissent le handle de fichier ouvert en cas d'erreur. La réponse https://stackoverflow.com/a/15053443/2498188 est sur l'argent, mais seulement parce que BufferedWriter() Je ne peux pas lancer. Si cela pouvait alors une exception laisserait le FileWriter objet ouvert.

Une façon plus générale de faire cela qui ne se soucie pas si BufferedWriter() peut jeter:

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

Modifier:

A partir de Java 7, il est recommandé d'utiliser "try with resources" et de laisser la JVM s'occuper de cela:

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

19
2017-09-11 16:50



Pour développer légèrement sur La réponse de Kip, voici une méthode simple Java 7+ pour ajouter un nouvelle ligne dans un fichier, le créer s'il n'existe pas déjà:

try {
    final Path path = Paths.get("path/to/filename.txt");
    Files.write(path, Arrays.asList("New line to append"), StandardCharsets.UTF_8,
        Files.exists(path) ? StandardOpenOption.APPEND : StandardOpenOption.CREATE);
} catch (final IOException ioe) {
    // Add your own exception handling...
}

Remarque: Ce qui précède utilise le Files.write surcharge qui écrit lignes du texte dans un fichier (c'est-à-dire similaire à printlncommander). Pour écrire un texte à la fin (c'est-à-dire similaire à un print commande), une alternative Files.write une surcharge peut être utilisée en passant dans un réseau d'octets (par ex. "mytext".getBytes(StandardCharsets.UTF_8)).


15
2018-06-01 08:03



En Java-7, on peut aussi faire ce genre:

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

// ---------------------

Path filePath = Paths.get("someFile.txt");
if (!Files.exists(filePath)) {
    Files.createFile(filePath);
}
Files.write(filePath, "Text to be added".getBytes(), StandardOpenOption.APPEND);

13
2018-04-05 11:03



Échantillon, en utilisant goyave:

File to = new File("C:/test/test.csv");

for (int i = 0; i < 42; i++) {
    CharSequence from = "some string" + i + "\n";
    Files.append(from, to, Charsets.UTF_8);
}

6
2018-06-04 19:17



Cela peut être fait dans une ligne de code. J'espère que cela t'aides :)

Files.write(Paths.get(fileName), msg.getBytes(), StandardOpenOption.APPEND);

6
2017-08-06 17:38