Is this the best way to rewrite the content of a file in Java?

Question

I want to rewrite the contents of a file.

What I have thought of so far is this:

1. Save the file name
2. Delete the existing file
3. Create a new empty file with the same name
4. Write the desired content to the empty file

Is this the best way? Or is there a more direct way, that is, not having to delete and create files, but simply change the content?

Answer 1

To overwrite file foo.log with FileOutputStream:

File myFoo = new File("foo.log");
FileOutputStream fooStream = new FileOutputStream(myFoo, false); // true to append
                                                                 // false to overwrite.
byte[] myBytes = "New Contents\n".getBytes(); 
fooStream.write(myBytes);
fooStream.close();

or with FileWriter :

File myFoo = new File("foo.log");
FileWriter fooWriter = new FileWriter(myFoo, false); // true to append
                                                     // false to overwrite.
fooWriter.write("New Contents\n");
fooWriter.close();

Answer 2

I would highly recommend using the Apache Common's FileUtil for this. I have found this package invaluable. It's easy to use and equally important it's easy to read/understand when you go back a while later.

//Create some files here
File sourceFile = new File("pathToYourFile");
File fileToCopy = new File("copyPath");

//Sample content
org.apache.commons.io.FileUtils.writeStringToFile(sourceFile, "Sample content");

//Now copy from source to copy, the delete source.
org.apache.commons.io.FileUtils.copyFile(sourceFile, fileToCopy);
org.apache.commons.io.FileUtils.deleteQuietly(sourceFile);

More information can be found at: http://commons.apache.org/io/api-release/org/apache/commons/io/FileUtils.html

Answer 3

See: java.io.RandomAccessFile

You'll want to open a File read-write, so:

RandomAccessFile raf = new RandomAccessFile("filename.txt", "rw");
String tmp;
while (tmp = raf.readLine() != null) {
    // Store String data
}
// do some string conversion
raf.seek(0);
raf.writeChars("newString");

Answer 4

Since Java 7 and the new file API this is really simple using the java.nio.file.Files class:

Files.write(Path.of("foo.log"), "content".getBytes(StandardCharsets.UTF_8));

New in Java 8 to write list of UTF-8 string:

Files.write(Path.of("foo.log"), List.of("content line 1", "content line 2"));

New in Java 11 to write UTF-8 string:

Files.writeString(Path.of("foo.log"), "content");

Answer 5

Unless you're just adding content at the end, it's reasonable to do it that way. If you are appending, try FileWriter with the append constructor.

A slightly better order would be:

1. Generate new file name (e.g. foo.txt.new)
2. Write updated content to new file.
3. Do atomic rename from foo.txt.new to foo.txt

Unfortunately, renameTo is not guaranteed to do atomic rename.

Answer 6

In the below example, the "false" causes the file to be overwritten, true would cause the opposite.

File file=new File("C:\Path\to\file.txt");
DataOutputStream outstream= new DataOutputStream(new FileOutputStream(file,false));
String body = "new content";
outstream.write(body.getBytes());
outstream.close(); 

Answer 7

There are times when one may want to keep a huge empty file so as to avoid extra cost of the OS allocating space on need basis. This is generally done by databases, Virtual machines and also in batch programs that process and write bulk data. This would improve the performance of the application significantly. In these cases, writing a new file and renaming it would not really help. Instead, the empty file will have to be filled up. That is when one must go for the override mode.

Answer 8

Guava Files.write "Overwrites a file with the contents of a byte array":

Files.write(bytes, new File(path));