Summary

Override readAllBytes, readNBytes, and transferTo in ByteArrayInputStream.

Problem

The methods readAllBytes, readNBytes, and transferTo were added to InputStream in JDK 9. When invoked on a ByteArrayInputStream however their implementations will be less efficient that if the internal byte array were used directly.

Solution

Override readAllBytes, readNBytes, and transferTo in ByteArrayInputStream to use the internal byte array directly.

Specification

Overrides in java.io.ByteArrayInputStream:

    /**
     * Reads all remaining bytes from the input stream.  This method does not
     * block.  This method does not close the input stream.
     *
     * When this stream reaches end of stream, further invocations of this
     * method will return an empty byte array.
     *
     * @throws OutOfMemoryError {@inheritDoc}
     *
     * @return {@inheritDoc}
     *
     * @since 10
     */
    public byte[] readAllBytes() {}

    /**
     * Reads the requested number of bytes from the input stream into the
     * given byte array.  This method does not close the input stream.  When
     * this stream reaches end of stream, further invocations of this method
     * will return zero.
     *
     * @apiNote
     * The {@code readNBytes(b, off, len)} method for this
     * class has the same effect as {@link #read(byte[],int,int)
     * read(b, off, len)} except that zero will be returned instead of
     * {@code -1} at end of stream.
     *
     * @param   b     {@inheritDoc}
     * @param   off   {@inheritDoc}
     * @param   len   {@inheritDoc}
     * @return  {@inheritDoc}
     * @throws  NullPointerException {@inheritDoc}
     * @throws  IndexOutOfBoundsException {@inheritDoc}
     *
     * @since 10
     */
    public int readNBytes(byte[] b, int off, int len) {}

    /**
     * Reads the remaining bytes from this input stream and writes the bytes
     * to the given output stream in the order that they were read.  On return,
     * this input stream will be at end of stream.  This method does not close
     * the output stream.
     * <p>
     * This method may block indefinitely writing to the output stream.  The
     * behavior for the case where the output stream is <i>asynchronously
     * closed</i>, or the thread is interrupted during the transfer, is highly
     * output stream specific, and therefore not specified.
     * <p>
     * If an I/O error occurs writing to the output stream, then it may do so
     * after some bytes have been written.  Consequently the input stream may
     * not be at end of stream and one, or both, streams may be in an
     * inconsistent state.  It is strongly recommended that the output stream
     * be promptly closed if an I/O error occurs.
     *
     * @param  out {@inheritDoc}
     * @return {@inheritDoc}
     * @throws IOException if an I/O error occurs when writing
     * @throws NullPointerException {@inheritDoc}
     *
     * @since 10
     */
    public long transferTo(OutputStream out) throws IOException {}