mjhjmtu

With Java 11, I could initialize an InputStream as:

InputStream inputStream = InputStream.nullInputStream();

But I am unable to understand a potential use case of InputStream.nullInputStream or a similar API for OutputStream
i.e. OutputStream.nullOutputStream.

From the API Javadocs, I could figure out that it

Returns a new InputStream that reads no bytes. The returned stream is
initially open. The stream is closed by calling the close() method.

Subsequent calls to close() have no effect. While the stream is open,
the available(), read(), read(byte), ...
skip(long), and transferTo() methods all behave as if end of stream
has been reached.

I went through the detailed release notes further which states:

There are various times where I would like to use methods that require
as a parameter a target OutputStream/Writer for sending output, but
would like to execute those methods silently for their other effects.

This corresponds to the ability in Unix to redirect command output to
/dev/null, or in DOS to append command output to NUL.

Yet I fail to understand what are those methods in the statement as stated as .... execute those methods silently for their other effects. (blame my lack of hands-on with the APIs)

Can someone help me understand what is the usefulness of having such an input or output stream with a help of an example if possible?

Edit: One of a similar implementation I could find on browsing further is apache-commons' NullInputStream, which does justify the testing use case much better.

Sometimes you want to have a parameter of InputStream type, but also to be able to choose not to feed your code with any data. In tests it's probably easier to mock it but in production you may choose to bind null input instead of scattering your code with ifs and flags.

compare:

class ComposableReprinter 
 void reprint(InputStream is) throws IOException 
 System.out.println(is.read());
 

 void bla() 
 reprint(InputStream.nullInputStream());
 

with this:

class ControllableReprinter 
 void reprint(InputStream is, boolean for_real) throws IOException 
 if (for_real) 
 System.out.println(is.read());
 
 
 void bla() 
 reprint(new BufferedInputStream(), false);
 

or this:

class NullableReprinter 
 void reprint(InputStream is) throws IOException 
 if (is != null) 
 System.out.println(is.read());
 
 
 void bla() 
 reprint(null);
 

It makes more sense with output IMHO. Input is probably more for consistency.

This approach is called Null Object: https://en.wikipedia.org/wiki/Null_object_pattern

I see it as a safer (1) and more expressive (2) alternative to initialising a stream variable with null.

1. No worries about NPEs.


2. 
   [Output|Input]Stream is an abstraction. In order to return a null/empty/mock stream, you had to deviate from the core concept down to a specific implementation.

I think nullOutputStream is very easy and clear: just to discard output (similar to > /dev/null) and/or for testing (no need to invent an OutputStream).

An (obviously basic) example:

OutputStream out = ... // an easy way to either print it to System.out or just discard all prints, setting it basically to the nullOutputStream
out.println("yeah... or not");
exporter.exportTo(out); // discard or real export?

Regarding nullInputStream it's probably more for testing (I don't like mocks) and APIs requiring an input stream or (this now being more probable) delivering an input stream which does not contain any data, or you can't deliver and where null is not a viable option:

importer.importDocument("name", /* input stream... */);
InputStream inputStream = content.getInputStream(); // better having no data to read, then getting a null

When you test that importer, you can just use a nullInputStream there, again instead of inventing your own InputStream or instead of using a mock. Other use cases here rather look like a workaround or misuse of the API ;-)

Regarding the return of an InputStream: that rather makes sense. If you haven't any data you may want to return that nullInputStream instead of null so that callers do not have to deal with null and can just read as they would if there was data.

Finally, these are just convenience methods to make our lifes easier without adding another dependency ;-) and as others already stated (comments/answers), it's basically an implementation of the null object pattern.

Using the null*Stream might also have the benefit that tests are executed faster... if you stream real data (of course... depending on size, etc.) you may just slow down your tests unnecessarily and we all want tests to complete fast, right? (some will put in mocks here... well...)