I have the following statement:
DataInputStream is = new DataInputStream(process.getInputStream());
I would like to print the contents of this input stream but I dont know the size of this stream. How should I read this stream and print it?
It is best to use buffer sizes that are multiples of 1024 bytes. That works best with most built-in buffering in hard disks etc. Except for adding buffering to your input streams, the Java BufferedOutputStream behaves exactly like an OutputStream .
A data input stream lets an application read primitive Java data types from an underlying input stream in a machine-independent way. An application uses a data output stream to write data that can later be read by a data input stream.
DataInputStream is a kind of InputStream to read data directly as primitive data types. BufferedInputStream is a kind of inputStream that reads data from a stream and uses a buffer to optimize speed access to data. data is basicaly read ahead of time and this reduces disk or network access.
If you can mark the stream when you read, then call reset() to go back to begin. If you can't you'll have to open a stream again. Another solution would be to convert InputStream to byte array, then iterate over the array as many time as you need.
It is common to all Streams, that the length is not known in advance. Using a standard InputStream
the usual solution is to simply call read
until -1
is returned.
But I assume, that you have wrapped a standard InputStream
with a DataInputStream
for a good reason: To parse binary data. (Note: Scanner
is for textual data only.)
The JavaDoc for DataInputStream
shows you, that this class has two different ways to indicate EOF - each method either returns -1
or throws an EOFException
. A rule of thumb is:
InputStream
uses the "return -1
" convention,InputStream
throws the EOFException
.If you use readShort
for example, read until an exception is thrown, if you use "read()", do so until -1
is returned.
Tip: Be very careful in the beginning and lookup each method you use from DataInputStream
- a rule of thumb can break.
Call is.read(byte[])
repeadely, passing a pre-allocated buffer (you can keep reusing the same buffer). The function will return the number of bytes actually read, or -1 at the end of the stream (in which case, stop):
byte[] buf = new byte[8192];
int nread;
while ((nread = is.read(buf)) >= 0) {
// process the first `nread` bytes of `buf`
}
byte[] buffer = new byte[100];
int numberRead = 0;
do{
numberRead = is.read(buffer);
if (numberRead != -1){
// do work here
}
}while (numberRead == buffer.length);
Keep reading a set buffer size in a loop. If the return value is ever less than the size of the buffer you know you have reached the end of the stream. If the return value is -1, there is no data in the buffer.
DataInputStream.read
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With