about the close method() used for closing a stream

Question

Today, when I was working on some kind of servlet which was writing some information to some file present on my hard disk, I was using the following code to perform the write operation

 File f=new File("c:/users/dell/desktop/ja/MyLOgs.txt");
        PrintWriter out=new PrintWriter(new FileWriter(f,true));
        out.println("the name of the  user is "+name+"\n");
        out.println("the email of the user is "+ email+"\n");
        out.close();             //**my question is about this statement**

When I was not using the statement, the servlet was compiling well, but it was not writing anything to the file, but when I included it, then the write operation was successfully performed. My questions are:

1. Why was the data not being written to the file when I was not including that statement (even my servlet was compiling without any errors)?
2. Up to which extent the close operation is considerable for the streams?

Answer 1

Calling close() causes all the data to be flushed. You have constructed a PrintWriter without enabling auto-flush (a second argument to one of the constructors), which would mean you would have to manually call flush() , which close() does for you.

Closing also frees up any system resources used by having the file open. Although the VM and Operating System will eventually close the file, it is good practice to close it when you are finished with it to save memory on the computer.

You may also which to put the close() inside a finally block to ensure it always gets called. Such as:

PrintWriter out = null;
try {
    File f = new File("c:/users/dell/desktop/ja/MyLOgs.txt");
    out = new PrintWriter(new FileWriter(f,true));
    out.println("the name of the  user is "+name+"\n");
    out.println("the email of the user is "+ email+"\n");
} finally {
    out.close();
}

See: PrintWriter

Sanchit also makes a good point about getting the Java 7 VM to automatically close your streams the moment you don't need them automatically.

Answer 2

When you close a PrintWriter , it will flush all of its data out to wherever you want the data to go. It doesn't automatically do this because if it did every time you wrote to something, it would be very inefficient as writing is not an easy process.

You could achieve the same effect with flush(); , but you should always close streams - see here: http://www.javapractices.com/topic/TopicAction.do?Id=8 and here: http://docs.oracle.com/javase/tutorial/jndi/ldap/close.html . Always call close(); on streams when you are done using them. Additionally, to make sure it is always closed regardless of exceptions, you could do this:

try {
    //do stuff
} finally {
    outputStream.close():
}

Answer 3

It is because the PrintWriter buffers your data in order for not making I/O operations repeatedly for every write operation (which is very expensive). When you call close() the Buffer flushes into the file. You can also call flush() for forcing the data to be written without closing the stream.

Answer 4

Streams automatically flush their data before closing. So you can either manually flush the data every once in a while using out.flush(); or you can just close the stream once you are done with it. When the program ends, streams close and your data gets flushed, this is why most of the time people do not close their streams!

Using Java 7 you can do something like this below which will auto close your streams in the order you open them.

public static void main(String[] args) {
  String name = "";
  String email = "";
  File f = new File("c:/users/dell/desktop/ja/MyLOgs.txt");
  try (FileWriter fw = new FileWriter(f, true); PrintWriter out = new PrintWriter(fw);) {
    out.println("the name of the  user is " + name + "\n");
    out.println("the email of the user is " + email + "\n");
  } catch (IOException e) {
    e.printStackTrace();
  }
}

Answer 5

PrintWriter buffers the data to be written so and will not write to disk until its buffer is full. Calling close() will ensure that any remaining data is flushed as well as closing the OutputStream .

close() statements typically appear in finally blocks.

Answer 6

Why the data was not being written to the file when I was not including that statement?

When the process terminates the unmanaged resources will be released. For InputStreams this is fine. For OutputStreams, you could lose an buffered data, so you should at least flush the stream before exiting the program.