Input and output are often the performance bottlenecks in a program. Reading from or writing to disk can be hundreds of times slower than reading from or writing to memory; network connections and user input are even slower. While disk capacities and speeds have increased over time, they have never kept pace with CPU speeds. Therefore, it’s important to minimize the number of reads and writes a program actually performs.
All input streams have overloaded
that read chunks of contiguous data into a
array. The first variant tries to read enough data to fill the array
data. The second variant tries to read
length bytes of data starting at position
offset into the array
Neither of these methods is guaranteed to read as many bytes as they
want. Both methods return the number of bytes actually read, or -1 on
end of stream.
public int read(byte data) throws IOException public int read(byte data, int offset, int length) throws IOException
The default implementation of these methods in the
java.io.InputStream class merely calls the basic
read() method enough times to fill the requested
array or subarray. Thus, reading 10 bytes of data takes 10 times as
long as reading one byte of data. However, most subclasses of
InputStream override these methods with more
efficient methods, perhaps native, that read the data from the
underlying source as a block.
For example, to attempt to read 10 bytes from
System.in, you could write the following ...