BufferedWriter not writing everything to its output file
You must close()
your BufferedWriter
. You must close()
your BufferedWriter
because it IS-A Writer
and thus implements AutoCloseable
, which means (emphasis added) it is
A resource that must be closed when it is no longer needed.
Some people say you must first call flush()
for your BufferedWriter
before calling close()
. They are wrong. The documentation for BufferedWriter.close()
notes that it "Closes the stream, flushing it first" (emphasis added).
The documented semantics of flushing (flush()
) are
Flushes this stream by writing any buffered output to the underlying stream
So, you must close
, and close
will flush any buffered output.
Your output file does not include all the text you wrote to your BufferedWriter
because it stored some of that text in a buffer. The BufferedWriter
never emptied that buffer, passing it through to the file, because you never told it to do so.
Since Java 7, the best way to ensure an AutoCloseable
resource, such as a BufferedWriter
, is closed when it is not longer need is to use automatic resource management (ARM), also known as try-with-resources:
try (BufferedWriter out = new BufferedWriter(new FileWriter(file))) {
// writes to out here
} catch (IOException ex) {
// handle ex
}
You must also close
your BufferedReader
when it is no longer need, so you should have nested try-with-resources blocks:
try (BufferedReader in = new BufferedReader(new FileReader("nyccrash.txt")) {
try (BufferedWriter out = new BufferedWriter(new FileWriter("nyccrash.sql"))) {
// your reading and writing code here
}
} catch (IOException ex) {
// handle ex
}
Do not be tempted (as other answers here suggest) just to call close()
at the end of your method, when your code has "finished" using the writer. That will not work if your writing code throws an exception, and in particular if it throws an IOException
.
You need to close your OutputStream
which will flush the remainder of your data:
out.close();
The default buffer size for BufferedWriter
is 8192 characters, large enough to easily hold hundreds of lines of unwritten data.