Overload optimized FileInputStream::readAllBytes

ADDITIONAL SYSTEM INFORMATION :
Here is a JMH benchmark which gives an implementation example and shows 30% performance gain for 10MB sized files on Windows. For smaller files there is less improvement but i did not see any degradation on any file size from 100Byte to 10MB:

package benchmarks;

import java.io.IOException;
import java.util.Arrays;

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.TearDown;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

@BenchmarkMode(org.openjdk.jmh.annotations.Mode.SingleShotTime)
@OutputTimeUnit(java.util.concurrent.TimeUnit.MILLISECONDS)
@State(org.openjdk.jmh.annotations.Scope.Thread)
@Fork(value = 1, jvmArgsAppend = { "-ea" })
@Warmup(batchSize = 1000)
@Measurement(batchSize = 1000)
public class FileRead {
// XXX put in any directory where the files are located.
String dirName = "resources/";
// XXX put in any filenames you like to test.
@Param({ "100b.txt", "1k.txt", "10k.txt", "100k.txt", "1MB.txt", "10MB.txt" })
String fileName;

java.io.File file;
byte[] result;
byte[] expected;

@Setup
public void setup() throws IOException {
file = new java.io.File(dirName + fileName).getAbsoluteFile();
result = null;
expected = java.nio.file.Files.readAllBytes(file.toPath());
}

@TearDown
public void check() {
assert Arrays.equals(expected, result) : "Nothing changed?";
}

public static final int MAX_ARRAY_LENGTH = Integer.MAX_VALUE - 8;

@Benchmark
public void readAllBytesOld() throws IOException {
try (java.io.InputStream input = new java.io.FileInputStream(file)) {
result = input.readAllBytes();
}
}

@Benchmark
public void readAllBytesNew() throws IOException {
try (java.io.InputStream input = new java.io.FileInputStream(file) {

@Override
public byte[] readAllBytes() throws IOException {
long length = this.getChannel().size();
// use jdk.internal.util.ArraysSupport.newLength(int, int, int)?
if (length > MAX_ARRAY_LENGTH)
throw new OutOfMemoryError("File too large for array: " + length);
return readNBytes(this, (int) length);
}

byte[] readNBytes(java.io.InputStream input, int byteLength) throws IOException {
if (byteLength == 0)
return new byte[0];
byte[] byteBuf = new byte[byteLength]; // exact buffer size
int byteCount = 0;
int byteTransferSize = byteBuf.length;
int bytesRead;
while ((bytesRead = input.read(byteBuf, byteCount, byteTransferSize)) >= 0) {
byteCount += bytesRead;
byteTransferSize = byteBuf.length - byteCount;
if (byteTransferSize <= 0) {
break;
}
}
return (byteBuf.length == byteCount) ? byteBuf : Arrays.copyOf(byteBuf, byteCount);
}
}) {
result = input.readAllBytes();
}
}

public static void main(String[] args) throws RunnerException, InterruptedException {
Options opt = new OptionsBuilder().include(FileRead.class.getSimpleName()).shouldFailOnError(true).build();
new Runner(opt).run();
}
}

My results:

Benchmark (fileName) Mode Cnt Score Error Units
ReadByt3.readAllBytesNew 100b.txt ss 34,081 ms/op
ReadByt3.readAllBytesNew 1k.txt ss 35,951 ms/op
ReadByt3.readAllBytesNew 10k.txt ss 40,996 ms/op
ReadByt3.readAllBytesNew 100k.txt ss 66,433 ms/op
ReadByt3.readAllBytesNew 1MB.txt ss 587,246 ms/op
ReadByt3.readAllBytesNew 10MB.txt ss 5361,234 ms/op

ReadByt3.readAllBytesOld 100b.txt ss 35,115 ms/op
ReadByt3.readAllBytesOld 1k.txt ss 35,951 ms/op
ReadByt3.readAllBytesOld 10k.txt ss 45,528 ms/op
ReadByt3.readAllBytesOld 100k.txt ss 125,894 ms/op
ReadByt3.readAllBytesOld 1MB.txt ss 630,972 ms/op
ReadByt3.readAllBytesOld 10MB.txt ss 7538,637 ms/op


A DESCRIPTION OF THE PROBLEM :
InputStream::readAllBytes currently reads all bytes through a series of buffers (https://bugs.openjdk.java.net/browse/JDK-8193832). For local files - where the filesize is known in advance- this could be optimized by reading all bytes at once from OS. Thus avoiding additional array creations and Array copies.
Reading all bytes at once is for example heavily used on products like the eclipse IDE.