Java: What sense could it make not to close an InputStream after it ended?

Question

InputStream implements Closeable.

I understand, that closing an InputStream which not ended yet, could make sense to free some underlying resources, and, leaving it open, could make sense to let other methods continue to read from it.

But, what sense could it have not to close an InputStream after it ended?
And if it doesn't make sense, why reaching the end of an InpuntStream does not imply closing then?

Same question would apply to Reader.

Answer 1

Closes this input stream and releases any system resources associated with the stream.

Resources here are The resources assigned to the VM by the operating system

from doc

Answer 2

I'm not aware of the semantics connected with InputStream in java, but in general, you might not close a stream because you didn't open it yourself and just did work on it, and rely on the calling party (another method) to close the stream. If you opened the stream yourself, you shoudl always close it.

Answer 3

mark() and reset() allow you to "go back" in some implementations of the interface.

This is useful when implementing parsers and matching regexps as you usually want to lookahead.

Answer 4

In response to your comment to org.life.java

I know, and the question was: why an end of an InputStream does not imply close()?

Because, for some streams, you can rewind them and start reading again. For others, e.g. Sockets, it's not possible, but they have to obey the contract rules.

Also, because that's how you should close stream ( exception handling not shown ):

InputStream stream = openMethod( );

try
{
   consumeMethod( stream );
}
finally
{
   stream.close( );
}

In other words, you should release acquired resources regardless whether you totally consumed the stream or not.

Answer 5

Implicitly closing would not be so good, because

• it would only be done when the stream has reached its end, which may not be the case always (some exceptions occur on the way, or you only read the first bytes of a file), so you have to handle these other cases anyway. Having an implicit close that almost always works makes people even more forgetful about their finally blocks.
• some streams can be rewound (mark/reset).

Answer 6

A reason under Windows could be to keep the file locked. Open files cannot be renamed, deleted or moved.

Answer 7

You can mark() and reset() an InputStream. Therefore, once you reach the end of the data, you can still return to the position that you marked. Someone who wants to reset() an InputStream might not want it to close at the end.

Answer 8

Judging from InputStream's API, there is no problem for a particular implementation to do that, i.e. close upon end of stream. It is probably a very good idea for a lot of streams.