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

Question

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

5 answers so far, *all* quoting the javadoc. Guess that's a sign to *read the doc*. — Andreas, Sep 01 '15 at 06:40
@Andreas all those answers quote the Javadoc of some Writer class. Thus they all answer only the second, follow-up question of the OP. Only one answer _addresses_ the first, more general question (but does not really answer it, either). — Qw3ry, Dec 02 '19 at 13:53
@Qw3ry What do you mean? They all answer it, by quoting the `Writer` javadoc saying that closing auto-flushes for you. The question is *entirely* about `Writer`, because it is the Writer class, not the (Auto)Closeable interface, that *declares* the **`flush()`** method that is the primary topic of the question, so there is no "more general" answer to the question. — Andreas, Dec 02 '19 at 22:14
@Andreas it's true that (Auto)Closeable doesn't declare `flush()`, but actually it's not `Writer` that declares it either. The [`Writer`-Javadoc](https://docs.oracle.com/javase/7/docs/api/java/io/Writer.html#flush()) of `flush()` explicitely refers to the declaration in `Flushable`. Writer only _overrides_ `flush()`. Because `Flushable` does not extend (Auto)Closeable, its declaration cannot say anything on implementions of `close()`. — Qw3ry, Dec 03 '19 at 11:52

score 29 · Accepted Answer · answered Sep 01 '15 at 06:06

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.

score 11 · Answer 2 · answered Sep 01 '15 at 06:03

The resources are automatically closed when using try-with-resource block. As part of this process it will also invoke flush automatically.

As mentioned in doc for close method of BufferedWriter:

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

score 5 · Answer 3 · answered Nov 08 '19 at 19:03

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

score 4 · Answer 4 · answered Sep 01 '15 at 06:03

4

Quoting javadoc of BufferedWriter.close():

Closes the stream, flushing it first.

answered Sep 01 '15 at 06:03

Andreas

154,647
11
152
247

Olimpiu POP · Answer 5 · 2015-09-01T06:20:18.397

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.

score 2 · Answer 6 · edited Aug 12 '16 at 08:44

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.

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

6 Answers6

Linked

Related