Comment ajouter du texte à un fichier existant dans Java
Je dois ajouter du texte à plusieurs reprises à un fichier existant en Java. Comment je fais ça?
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 cela une fois, la 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 jettera un NoSuchFileException si le fichier n’existe pas déjà. De plus, il n’ajoute pas automatiquement de nouvelle ligne (ce que vous voulez souvent quand vous ajoutez un fichier texte). La réponse de Steve Chambers explique comment vous pouvez faire cela avec Files class.
Toutefois, si vous écrivez plusieurs fois dans le même fichier, le programme ci-dessus doit ouvrir et fermer le fichier sur le disque plusieurs fois, ce qui constitue une opération lente. Dans ce cas, un écrivain tamponné est préférable:
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 second paramètre du constructeur
FileWriterlui indiquera d’ajouter au fichier plutôt que d’écrire un nouveau fichier. (Si le fichier n'existe pas, il sera créé.) - L'utilisation de
BufferedWriterest recommandée pour un graveur coûteux (tel queFileWriter). - L'utilisation d'un
PrintWritervous donne accès à la syntaxeprintlnà laquelle vous êtes probablement habitué à partir deSystem.out. - Mais les
BufferedWriteretPrintWriterenveloppes ne sont pas strictement nécessaires.
Java plus 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 les versions antérieures de Java, vous obtiendrez des informations très détaillées:
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
}
}
Vous pouvez utiliser fileWriter avec un indicateur défini sur 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());
}
Toutes les réponses données ici avec les blocs try/catch ne doivent-elles pas contenir les éléments .close () contenus 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();
}
}
En outre, à partir de Java 7, vous pouvez utiliser une instruction instruction try-with-resources . Enfin, aucun bloc n'est requis pour fermer les ressources déclarées car elles sont gérées automatiquement et sont également moins explicites:
try(PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("writePath", true)))) {
out.println("the text");
} catch (IOException e) {
System.err.println(e);
}
Edit - depuis Apache Commons 2.1, la bonne façon de le faire est la suivante:
FileUtils.writeStringToFile(file, "String to append", true);
J'ai adapté la solution de @ Kip pour inclure la fermeture correcte du fichier enfin:
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(); } } }
Pour développer légèrement la réponse de Kip , voici une méthode simple Java 7+ pour ajouter une nouvelle ligne dans un fichier, le créant 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...
}
_Note: Ce qui précède utilise la surcharge Files.write qui écrit lignes dans un fichier (c'est-à-dire similaire à un println commande). Pour simplement écrire du texte à la fin (similaire à une commande print), une alternative Files.write peut être utilisée, en passant à un tableau d'octets (par exemple, "mytext".getBytes(StandardCharsets.UTF_8)).
Assurez-vous que le flux est correctement fermé dans tous les scénarios.
Il est un peu alarmant de voir combien de ces réponses laissent le descripteur 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() ne peut pas lancer. S'il le pouvait, une exception laisserait l'objet FileWriter ouvert.
Une façon plus générale de faire cela qui ne dérange pas 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
}
}
Modifier:
A partir de Java 7, la méthode recommandée consiste à utiliser "try with resources" et à 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.
}
En Java-7, il est également possible de faire ce genre de choses:
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);
Java 7 +
À mon humble avis, puisque je suis fan de Java, je dirais que c'est une combinaison des réponses susmentionnées. Peut-être que je suis en retard pour la fête. Voici le code:
String sampleText = "test" + System.getProperty("line.separator");
Files.write(Paths.get(filePath), sampleText.getBytes(StandardCharsets.UTF_8),
StandardOpenOption.CREATE, StandardOpenOption.APPEND);
Si le fichier n'existe pas, il le crée et s'il existe déjà, il ajoute le sampleText au fichier existant. Cela vous évite d’ajouter des bibliothèques inutiles à votre chemin de classe.
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);
Utilisation de Java.nio . Fichiers avec Java.nio.file . StandardOpenOption
PrintWriter out = null;
BufferedWriter bufWriter;
try{
bufWriter =
Files.newBufferedWriter(
Paths.get("log.txt"),
Charset.forName("UTF8"),
StandardOpenOption.WRITE,
StandardOpenOption.APPEND,
StandardOpenOption.CREATE);
out = new PrintWriter(bufWriter, true);
}catch(IOException e){
//Oh, no! Failed to create PrintWriter
}
//After successful creation of PrintWriter
out.println("Text to be appended");
//After done writing, remember to close!
out.close();
Cela crée une BufferedWriter utilisant Files, qui accepte les paramètres StandardOpenOption, ainsi qu'un vidage automatique PrintWriter de la résultante BufferedWriter. La méthode PrintWriter _ println(), peut ensuite être appelée pour écrire dans le fichier.
Les paramètres StandardOpenOption utilisés dans ce code: ouvre le fichier en écriture, ne fait qu'ajouter au fichier et crée le fichier s'il n'existe pas.
Paths.get("path here") peut être remplacé par new File("path here").toPath(). Et Charset.forName("charset name") peut être modifié pour s'adapter à la Charset souhaitée.
Je viens d'ajouter un petit détail:
new FileWriter("outfilename", true)
Le paramètre 2.nd (true) est une fonctionnalité (ou interface) appelée annexable ( http://docs.Oracle.com/ javase/7/docs/api/Java/lang/Appendable.html ). Il lui incombe d’ajouter du contenu à la fin d’un fichier/flux particulier. Cette interface est implémentée depuis Java 1.5. Chaque objet (c'est-à-dire BufferedWriter, CharArrayWriter, CharBuffer, FileWriter, FilterWriter, LogStream, OutputStreamWriter, PipedWriter, PrintStream, PrintWriter, StringBuffer, StringBuilder, StringWriter, Writer) avec cette interface peut être utilisé pour ajouter du contenu
En d’autres termes, vous pouvez ajouter du contenu à votre fichier gzip ou un processus http.
Échantillon avec 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);
}
Essayez avec bufferFileWriter.append, cela fonctionne avec moi.
FileWriter fileWriter;
try {
fileWriter = new FileWriter(file,true);
BufferedWriter bufferFileWriter = new BufferedWriter(fileWriter);
bufferFileWriter.append(obj.toJSONString());
bufferFileWriter.newLine();
bufferFileWriter.close();
} catch (IOException ex) {
Logger.getLogger(JsonTest.class.getName()).log(Level.SEVERE, null, ex);
}
Il est préférable d’utiliser des ressources d’essai, puis tout ce qui précède Java 7 a finalement été adopté.
static void appendStringToFile(Path file, String s) throws IOException {
try (BufferedWriter out = Files.newBufferedWriter(file, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
out.append(s);
out.newLine();
}
}
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();
}
String str;
String path = "C:/Users/...the path..../iin.txt"; // you can input also..i created this way :P
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(new FileWriter(path, true));
try
{
while(true)
{
System.out.println("Enter the text : ");
str = br.readLine();
if(str.equalsIgnoreCase("exit"))
break;
else
pw.println(str);
}
}
catch (Exception e)
{
//oh noes!
}
finally
{
pw.close();
}
cela fera ce que vous avez l'intention de faire ..
import Java.io.BufferedWriter;
import Java.io.FileWriter;
import Java.io.IOException;
import Java.io.PrintWriter;
public class Writer {
public static void main(String args[]){
doWrite("output.txt","Content to be appended to file");
}
public static void doWrite(String filePath,String contentToBeAppended){
try(
FileWriter fw = new FileWriter(filePath, true);
BufferedWriter bw = new BufferedWriter(fw);
PrintWriter out = new PrintWriter(bw)
)
{
out.println(contentToBeAppended);
}
catch( IOException e ){
// File writing/opening failed at some stage.
}
}
}
FileOutputStream fos = new FileOutputStream("File_Name", true);
fos.write(data);
true permet d’ajouter les données dans le fichier existant. Si nous écrirons
FileOutputStream fos = new FileOutputStream("File_Name");
Cela écrasera le fichier existant. Alors allez-y pour la première approche.
Créez une fonction n'importe où dans votre projet et appelez-la simplement où vous en avez besoin.
Les gars, vous devez vous rappeler que vous appelez des threads actifs que vous n'appelez pas de manière asynchrone et qu'il serait vraisemblable qu'il faudrait 5 à 10 pages pour le faire correctement. Pourquoi ne pas consacrer plus de temps à votre projet et oublier d’écrire quoi que ce soit déjà écrit. Correctement
//Adding a static modifier would make this accessible anywhere in your app
public Logger getLogger()
{
return Java.util.logging.Logger.getLogger("MyLogFileName");
}
//call the method anywhere and append what you want to log
//Logger class will take care of putting timestamps for you
//plus the are ansychronously done so more of the
//processing power will go into your application
//from inside a function body in the same class ...{...
getLogger().log(Level.INFO,"the text you want to append");
...}...
/*********log file resides in server root log files********/
trois lignes de code deux réellement puisque la troisième ajoute du texte. : P
Bibliothèque
import Java.io.BufferedWriter;
import Java.io.File;
import Java.io.FileWriter;
import Java.io.IOException;
Code
public void append()
{
try
{
String path = "D:/sample.txt";
File file = new File(path);
FileWriter fileWriter = new FileWriter(file,true);
BufferedWriter bufferFileWriter = new BufferedWriter(fileWriter);
fileWriter.append("Sample text in the file to append");
bufferFileWriter.close();
System.out.println("User Registration Completed");
}catch(Exception ex)
{
System.out.println(ex);
}
}
Vous pouvez aussi essayer ceci:
JFileChooser c= new JFileChooser();
c.showOpenDialog(c);
File write_file = c.getSelectedFile();
String Content = "Writing into file"; //what u would like to append to the file
try
{
RandomAccessFile raf = new RandomAccessFile(write_file, "rw");
long length = raf.length();
//System.out.println(length);
raf.setLength(length + 1); //+ (integer value) for spacing
raf.seek(raf.length());
raf.writeBytes(Content);
raf.close();
}
catch (Exception e) {
//any exception handling method of ur choice
}
FileOutputStream stream = new FileOutputStream(path, true);
try {
stream.write(
string.getBytes("UTF-8") // Choose your encoding.
);
} finally {
stream.close();
}
Puis attrapez une exception IOException quelque part en amont.
Je pourrais suggérer le projet commun Apache . Ce projet fournit déjà un cadre pour faire ce dont vous avez besoin (c'est-à-dire un filtrage flexible des collections).
La méthode suivante vous permet d’ajouter du texte à un fichier:
private void appendToFile(String filePath, String text)
{
PrintWriter fileWriter = null;
try
{
fileWriter = new PrintWriter(new BufferedWriter(new FileWriter(
filePath, true)));
fileWriter.println(text);
} catch (IOException ioException)
{
ioException.printStackTrace();
} finally
{
if (fileWriter != null)
{
fileWriter.close();
}
}
}
Vous pouvez également utiliser FileUtils :
public static void appendToFile(String filePath, String text) throws IOException
{
File file = new File(filePath);
if(!file.exists())
{
file.createNewFile();
}
String fileContents = FileUtils.readFileToString(file);
if(file.length() != 0)
{
fileContents = fileContents.concat(System.lineSeparator());
}
fileContents = fileContents.concat(text);
FileUtils.writeStringToFile(file, fileContents);
}
Ce n'est pas efficace mais ça fonctionne bien. Les sauts de ligne sont gérés correctement et un nouveau fichier est créé s'il n'en existait pas encore.
Dans le cas où vous voudriez AJOUTER UN TEXTE DANS DES LIGNES SPÉCIFIQUES vous pouvez d’abord lire le fichier en entier, ajouter le texte où vous voulez et ensuite tout écraser, comme dans le code ci-dessous:
public static void addDatatoFile(String data1, String data2){
String fullPath = "/home/user/dir/file.csv";
File dir = new File(fullPath);
List<String> l = new LinkedList<String>();
try (BufferedReader br = new BufferedReader(new FileReader(dir))) {
String line;
int count = 0;
while ((line = br.readLine()) != null) {
if(count == 1){
//add data at the end of second line
line += data1;
}else if(count == 2){
//add other data at the end of third line
line += data2;
}
l.add(line);
count++;
}
br.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
createFileFromList(l, dir);
}
public static void createFileFromList(List<String> list, File f){
PrintWriter writer;
try {
writer = new PrintWriter(f, "UTF-8");
for (String d : list) {
writer.println(d.toString());
}
writer.close();
} catch (FileNotFoundException | UnsupportedEncodingException e) {
e.printStackTrace();
}
}
Ce code répondra à vos besoins:
FileWriter fw=new FileWriter("C:\\file.json",true);
fw.write("ssssss");
fw.close();
/**********************************************************************
* it will write content to a specified file
*
* @param keyString
* @throws IOException
*********************************************************************/
public static void writeToFile(String keyString,String textFilePAth) throws IOException {
// For output to file
File a = new File(textFilePAth);
if (!a.exists()) {
a.createNewFile();
}
FileWriter fw = new FileWriter(a.getAbsoluteFile(), true);
BufferedWriter bw = new BufferedWriter(fw);
bw.append(keyString);
bw.newLine();
bw.close();
}// end of writeToFile()
Ma réponse:
JFileChooser chooser= new JFileChooser();
chooser.showOpenDialog(chooser);
File file = chooser.getSelectedFile();
String Content = "What you want to append to file";
try
{
RandomAccessFile random = new RandomAccessFile(file, "rw");
long length = random.length();
random.setLength(length + 1);
random.seek(random.length());
random.writeBytes(Content);
random.close();
}
catch (Exception exception) {
//exception handling
}