src/java.base/share/classes/java/io/OutputStream.java

*** 1,7 ****
  /*
!  * Copyright (c) 1994, 2017, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
--- 1,7 ----
  /*
!  * Copyright (c) 1994, 2018, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
*** 45,54 ****
--- 45,99 ----
   * @see     java.io.OutputStream#write(int)
   * @since   1.0
   */
  public abstract class OutputStream implements Closeable, Flushable {
      /**
+      * Returns a new {@code OutputStream} which discards all bytes.  The
+      * returned stream is initially open.  The stream is closed by calling
+      * the {@code close()} method.  Subsequent calls to {@code close()} have
+      * no effect.
+      *
+      * <p> While the stream is open, the {@code write(int)}, {@code
+      * write(byte[])}, and {@code write(byte[], int, int)} methods do nothing.
+      * After the stream has been closed, these methods all throw {@code
+      * IOException}.
+      *
+      * <p> The {@code flush()} method does nothing.
+      *
+      * @return an {@code OutputStream} which discards all bytes
+      *
+      * @since 11
+      */
+     public static OutputStream nullOutputStream() {
+         return new OutputStream() {
+             private volatile boolean closed;
+ 
+             private void ensureOpen() throws IOException {
+                 if (closed) {
+                     throw new IOException("Stream closed");
+                 }
+             }
+ 
+             @Override
+             public void write(int b) throws IOException {
+                 ensureOpen();
+             }
+ 
+             @Override
+             public void write(byte b[], int off, int len) throws IOException {
+                 Objects.checkFromIndexSize(off, len, b.length);
+                 ensureOpen();
+             }
+ 
+             @Override
+             public void close() {
+                 closed = true;
+             }
+         };
+     }
+ 
+     /**
       * Writes the specified byte to this output stream. The general
       * contract for <code>write</code> is that one byte is written
       * to the output stream. The byte to be written is the eight
       * low-order bits of the argument <code>b</code>. The 24
       * high-order bits of <code>b</code> are ignored.
*** 104,114 ****
       * @exception  IOException  if an I/O error occurs. In particular,
       *             an <code>IOException</code> is thrown if the output
       *             stream is closed.
       */
      public void write(byte b[], int off, int len) throws IOException {
-         Objects.requireNonNull(b);
          Objects.checkFromIndexSize(off, len, b.length);
          // len == 0 condition implicitly handled by loop bounds
          for (int i = 0 ; i < len ; i++) {
              write(b[off + i]);
          }
--- 149,158 ----