Unsynchronized ByteArrayInputStream implementation (#109)

* Add a non-synchronized ByteArrayInputStream implementation - FastByteArrayInputStream

* Address review comments by @garydgregory

Author: adamretter

src/main/java/org/apache/commons/io/input/UnsynchronizedByteArrayInputStream.java

@@ -0,0 +1,183 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.io.input;
+
+import java.io.InputStream;
+import java.util.Objects;
+
+import static java.lang.Math.min;
+
+/**
+ * This is an alternative to {@link java.io.ByteArrayInputStream}
+ * which removes the synchronization overhead for non-concurrent
+ * access; as such this class is not thread-safe.
+ *
+ * @since 2.7
+ */
+//@NotThreadSafe
+public class UnsynchronizedByteArrayInputStream extends InputStream {
+
+    public static final int END_OF_STREAM = -1;
+
+    /**
+     * The underlying data buffer.
+     */
+    private final byte[] data;
+
+    /**
+     * End Of Data.
+     *
+     * Similar to data.length,
+     * i.e. the last readable offset + 1.
+     */
+    private final int eod;
+
+    /**
+     * Current offset in the data buffer.
+     */
+    private int offset;
+
+    /**
+     * The current mark (if any).
+     */
+    private int markedOffset;
+
+    /**
+     * Creates a new byte array input stream.
+     *
+     * @param data the buffer
+     */
+    public UnsynchronizedByteArrayInputStream(final byte[] data) {
+        Objects.requireNonNull(data);
+        this.data = data;
+        this.offset = 0;
+        this.eod = data.length;
+        this.markedOffset = this.offset;
+    }
+
+    /**
+     * Creates a new byte array input stream.
+     *
+     * @param data the buffer
+     * @param offset the offset into the buffer
+     *
+     * @throws IllegalArgumentException if the offset is less than zero
+     */
+    public UnsynchronizedByteArrayInputStream(final byte[] data, final int offset) {
+        Objects.requireNonNull(data);
+        if (offset < 0) {
+            throw new IllegalArgumentException("offset cannot be negative");
+        }
+        this.data = data;
+        this.offset = min(offset, data.length > 0 ? data.length: offset);
+        this.eod = data.length;
+        this.markedOffset = this.offset;
+    }
+
+
+    /**
+     * Creates a new byte array input stream.
+     *
+     * @param data the buffer
+     * @param offset the offset into the buffer
+     * @param length the length of the buffer
+     *
+     * @throws IllegalArgumentException if the offset or length less than zero
+     */
+    public UnsynchronizedByteArrayInputStream(final byte[] data, final int offset, final int length) {
+        Objects.requireNonNull(data);
+        if (offset < 0) {
+            throw new IllegalArgumentException("offset cannot be negative");
+        }
+        if (length < 0) {
+            throw new IllegalArgumentException("length cannot be negative");
+        }
+        this.data = data;
+        this.offset = min(offset, data.length > 0 ? data.length : offset);
+        this.eod = min(this.offset + length, data.length);
+        this.markedOffset = this.offset;
+    }
+
+    @Override
+    public int available() {
+        return offset < eod ? eod - offset : 0;
+    }
+
+    @Override
+    public int read() {
+        return offset < eod ? data[offset++] & 0xff : END_OF_STREAM;
+    }
+
+    @Override
+    public int read(final byte[] b) {
+        Objects.requireNonNull(b);
+        return read(b, 0, b.length);
+    }
+
+    @Override
+    public int read(final byte[] b, final int off, final int len) {
+        Objects.requireNonNull(b);
+        if (off < 0 || len < 0 || off + len > b.length) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        if (offset >= eod) {
+            return END_OF_STREAM;
+        }
+
+        int actualLen = eod - offset;
+        if (len < actualLen) {
+            actualLen = len;
+        }
+        if (actualLen <= 0) {
+            return 0;
+        }
+        System.arraycopy(data, offset, b, off, actualLen);
+        offset += actualLen;
+        return actualLen;
+    }
+
+    @Override
+    public long skip(final long n) {
+        if(n < 0) {
+            throw new IllegalArgumentException("Skipping backward is not supported");
+        }
+
+        long actualSkip = eod - offset;
+        if (n < actualSkip) {
+            actualSkip = n;
+        }
+
+        offset += actualSkip;
+        return actualSkip;
+    }
+
+    @Override
+    public boolean markSupported() {
+        return true;
+    }
+
+    @Override
+    public void mark(final int readlimit) {
+        this.markedOffset = this.offset;
+    }
+
+    @Override
+    public void reset() {
+        this.offset = this.markedOffset;
+    }
+}

src/main/java/org/apache/commons/io/output/AbstractByteArrayOutputStream.java

@@ -18,7 +18,6 @@
 
 import org.apache.commons.io.input.ClosedInputStream;
 
-import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.io.IOException;
 import java.io.OutputStream;
@@ -294,20 +293,26 @@ protected void writeToImpl(final OutputStream out) throws IOException {
      * returned stream is backed by buffers of <code>this</code> stream,
      * avoiding memory allocation and copy, thus saving space and time.<br>
      *
+     * @param <T> the type of the InputStream which makes up
+     *            the {@link SequenceInputStream}.
+     * @param isConstructor A constructor for an InputStream which makes
+     *                     up the {@link SequenceInputStream}.
+     *
      * @return the current contents of this output stream.
      * @see java.io.ByteArrayOutputStream#toByteArray()
      * @see #reset()
      * @since 2.7
      */
-    protected InputStream toInputStreamImpl() {
+    protected <T extends InputStream> InputStream toInputStreamImpl(
+            final InputStreamConstructor<T> isConstructor) {
         int remaining = count;
         if (remaining == 0) {
             return new ClosedInputStream();
         }
-        final List<ByteArrayInputStream> list = new ArrayList<>(buffers.size());
+        final List<T> list = new ArrayList<>(buffers.size());
         for (final byte[] buf : buffers) {
             final int c = Math.min(buf.length, remaining);
-            list.add(new ByteArrayInputStream(buf, 0, c));
+            list.add(isConstructor.construct(buf, 0, c));
             remaining -= c;
             if (remaining == 0) {
                 break;
@@ -317,6 +322,26 @@ protected InputStream toInputStreamImpl() {
         return new SequenceInputStream(Collections.enumeration(list));
     }
 
+    /**
+     * Constructor for an InputStream subclass.
+     *
+     * @param <T> the type of the InputStream.
+     */
+    @FunctionalInterface
+    protected interface InputStreamConstructor<T extends InputStream> {
+
+        /**
+         * Construct an InputStream subclass.
+         *
+         * @param buf the buffer
+         * @param offset the offset into the buffer
+         * @param length the length of the buffer
+         *
+         * @return the InputStream subclass.
+         */
+        T construct(final byte buf[], final int offset, final int length);
+    }
+
     /**
      * Gets the current contents of this byte stream as a byte array.
      * The result is independent of this stream.

src/main/java/org/apache/commons/io/output/ByteArrayOutputStream.java

@@ -158,7 +158,7 @@ public static InputStream toBufferedInputStream(final InputStream input, final i
 
     @Override
     public synchronized InputStream toInputStream() {
-        return toInputStreamImpl();
+        return toInputStreamImpl(java.io.ByteArrayInputStream::new);
     }
 
     @Override

src/main/java/org/apache/commons/io/output/UnsynchronizedByteArrayOutputStream.java

@@ -16,6 +16,8 @@
  */
 package org.apache.commons.io.output;
 
+import org.apache.commons.io.input.UnsynchronizedByteArrayInputStream;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
@@ -153,7 +155,7 @@ public static InputStream toBufferedInputStream(final InputStream input, final i
 
     @Override
     public InputStream toInputStream() {
-        return toInputStreamImpl();
+        return toInputStreamImpl(UnsynchronizedByteArrayInputStream::new);
     }
 
     @Override