Reputation: 3921

Is flush() call necessary when using try-with-resources

Will try-with-resources call flush() implicitly?

If it does, in the following code snippet, bw.flush() can be safely removed?

static void printToFile1(String text, File file) {
    try (BufferedWriter bw = new BufferedWriter(new FileWriter(file))) {
        bw.write(text);
        bw.flush();
    } catch (IOException ex) {
        // handle ex
    }
}

ps. I don't see any description about it in official document:

https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html https://docs.oracle.com/javase/8/docs/api/java/lang/AutoCloseable.html

Upvotes: 35

Answers (6)

Jin Kwon

Reputation: 22017

I really don't understand why other answers focus on the BufferedWriter not try-with-resources.

I, either, couldn't find any specification or mentions that the try-with-resources statements calls flush() on any objects of Flushable.

https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.20.3

Don't rely on any undocumented/unspecified behavior of vendor specific implementations.

try (OutputStream o = open()) {
    //writeSome
    o.flush(); // won't hurt!
}

Upvotes: 4

Rahul Tripathi

Reputation: 172578

From the Javdocs:

The try-with-resources statement is a try statement that declares one or more resources. A resource is an object that must be closed after the program is finished with it. The try-with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements java.lang.AutoCloseable, which includes all objects which implement java.io.Closeable, can be used as a resource.

The BufferedWriter.close() explicitly stated that:

Closes the stream, flushing it first. Once the stream has been closed, further write() or flush() invocations will cause an IOException to be thrown. Closing a previously closed stream has no effect.

Upvotes: 2

Olimpiu POP

Reputation: 5067

The minimum amount of code to be written in this case:

try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out))) {
    bw.write("Test");
} catch (IOException e) {
    // handle exception
}

Hence you don't need to call explicitly the flush method, as it will be called by the close method, as explained in the javadoc:

Closes the stream, flushing it first. Once the stream has been closed, further write() or flush() invocations will cause an IOException to be thrown. Closing a previously closed stream has no effect.

This behavior is inherited from the Writer class, hence besides BufferedWriter the same behavior is provided also by: CharArrayWriter, FilterWriter, OutputStreamWriter, PipedWriter, PrintWriter, StringWriter.

This behavior is not provided in the documentation of the tryWithResources or AutoCloseable as the behavior is specific to the given implementation of Writer. As Writerextends Closeable, it will call the close method when exiting the try {} block and the close method will first call flush as already mentioned.

Upvotes: 4

Seelenvirtuose

Reputation: 20648

Closeable and AutoCloseable are general-purpose interfaces that do not know anything about flushing. So you can't find any information about it in their documentation - except some words about releasing resources.

A Writer on the other hand is a more specific-purpose abstract class that now knows something about flushing. Some excerpt of the documentation for the method Writer.close():

Closes the stream, flushing it first.

So - yes - when using a writer, a close will always also flush. This basically means that you have to consult the documentation of the concrete classes that you are using when trying to find out what closing really does.

Upvotes: 31