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 not necessarily safe for multithreaded access.
Thread safety is optional and is the responsibility of users of
methods in this class.
| Method from java.io.DataInputStream Detail: |
|---|
 public final int read(byte[] b) throws IOException {
return in.read(b, 0, b.length);
}
Reads some number of bytes from the contained input stream and
stores them into the buffer array b. The number of
bytes actually read is returned as an integer. This method blocks
until input data is available, end of file is detected, or an
exception is thrown.
If b is null, a NullPointerException is
thrown. If the length of b is zero, then no bytes are
read and 0 is returned; otherwise, there is an attempt
to read at least one byte. If no byte is available because the
stream is at end of file, the value -1 is returned;
otherwise, at least one byte is read and stored into b.
The first byte read is stored into element b[0], the
next one into b[1], and so on. The number of bytes read
is, at most, equal to the length of b. Let k
be the number of bytes actually read; these bytes will be stored in
elements b[0] through b[k-1], leaving
elements b[k] through b[b.length-1]
unaffected.
The read(b) method has the same effect as:
read(b, 0, b.length)
|
public final int read(byte[] b,
int off,
int len) throws IOException {
return in.read(b, off, len);
} Reads up to len bytes of data from the contained
input stream into an array of bytes. An attempt is made to read
as many as len bytes, but a smaller number may be read,
possibly zero. The number of bytes actually read is returned as an
integer.
This method blocks until input data is available, end of file is
detected, or an exception is thrown.
If len is zero, then no bytes are read and
0 is returned; otherwise, there is an attempt to read at
least one byte. If no byte is available because the stream is at end of
file, the value -1 is returned; otherwise, at least one
byte is read and stored into b.
The first byte read is stored into element b[off], the
next one into b[off+1], and so on. The number of bytes read
is, at most, equal to len. Let k be the number of
bytes actually read; these bytes will be stored in elements
b[off] through b[off+k-1],
leaving elements b[off+k] through
b[off+len-1] unaffected.
In every case, elements b[0] through
b[off] and elements b[off+len] through
b[b.length-1] are unaffected. |
public final boolean readBoolean() throws IOException {
int ch = in.read();
if (ch < 0)
throw new EOFException();
return (ch != 0);
} |
public final byte readByte() throws IOException {
int ch = in.read();
if (ch < 0)
throw new EOFException();
return (byte)(ch);
} |
public final char readChar() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (char)((ch1 < < 8) + (ch2 < < 0));
} |
public final double readDouble() throws IOException {
return Double.longBitsToDouble(readLong());
} |
public final float readFloat() throws IOException {
return Float.intBitsToFloat(readInt());
} |
public final void readFully(byte[] b) throws IOException {
readFully(b, 0, b.length);
} |
public final void readFully(byte[] b,
int off,
int len) throws IOException {
if (len < 0)
throw new IndexOutOfBoundsException();
int n = 0;
while (n < len) {
int count = in.read(b, off + n, len - n);
if (count < 0)
throw new EOFException();
n += count;
}
} |
public final int readInt() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
int ch3 = in.read();
int ch4 = in.read();
if ((ch1 | ch2 | ch3 | ch4) < 0)
throw new EOFException();
return ((ch1 < < 24) + (ch2 < < 16) + (ch3 < < 8) + (ch4 < < 0));
} |
public final String readLine() throws IOException {
char buf[] = lineBuffer;
if (buf == null) {
buf = lineBuffer = new char[128];
}
int room = buf.length;
int offset = 0;
int c;
loop: while (true) {
switch (c = in.read()) {
case -1:
case '\n':
break loop;
case '\r':
int c2 = in.read();
if ((c2 != '\n') && (c2 != -1)) {
if (!(in instanceof PushbackInputStream)) {
this.in = new PushbackInputStream(in);
}
((PushbackInputStream)in).unread(c2);
}
break loop;
default:
if (--room < 0) {
buf = new char[offset + 128];
room = buf.length - offset - 1;
System.arraycopy(lineBuffer, 0, buf, 0, offset);
lineBuffer = buf;
}
buf[offset++] = (char) c;
break;
}
}
if ((c == -1) && (offset == 0)) {
return null;
}
return String.copyValueOf(buf, 0, offset);
} Deprecated! This - method does not properly convert bytes to characters.
As of JDK 1.1, the preferred way to read lines of text is via the
BufferedReader.readLine() method. Programs that use the
DataInputStream class to read lines can be converted to use
the BufferedReader class by replacing code of the form:
DataInputStream d = new DataInputStream(in);
with:
BufferedReader d
= new BufferedReader(new InputStreamReader(in));
|
public final long readLong() throws IOException {
readFully(readBuffer, 0, 8);
return (((long)readBuffer[0] < < 56) +
((long)(readBuffer[1] & 255) < < 48) +
((long)(readBuffer[2] & 255) < < 40) +
((long)(readBuffer[3] & 255) < < 32) +
((long)(readBuffer[4] & 255) < < 24) +
((readBuffer[5] & 255) < < 16) +
((readBuffer[6] & 255) < < 8) +
((readBuffer[7] & 255) < < 0));
} |
public final short readShort() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (short)((ch1 < < 8) + (ch2 < < 0));
} |
public final String readUTF() throws IOException {
return readUTF(this);
} |
public static final String readUTF(DataInput in) throws IOException {
int utflen = in.readUnsignedShort();
byte[] bytearr = null;
char[] chararr = null;
if (in instanceof DataInputStream) {
DataInputStream dis = (DataInputStream)in;
if (dis.bytearr.length < utflen){
dis.bytearr = new byte[utflen*2];
dis.chararr = new char[utflen*2];
}
chararr = dis.chararr;
bytearr = dis.bytearr;
} else {
bytearr = new byte[utflen];
chararr = new char[utflen];
}
int c, char2, char3;
int count = 0;
int chararr_count=0;
in.readFully(bytearr, 0, utflen);
while (count < utflen) {
c = (int) bytearr[count] & 0xff;
if (c > 127) break;
count++;
chararr[chararr_count++]=(char)c;
}
while (count < utflen) {
c = (int) bytearr[count] & 0xff;
switch (c > > 4) {
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
/* 0xxxxxxx*/
count++;
chararr[chararr_count++]=(char)c;
break;
case 12: case 13:
/* 110x xxxx 10xx xxxx*/
count += 2;
if (count > utflen)
throw new UTFDataFormatException(
"malformed input: partial character at end");
char2 = (int) bytearr[count-1];
if ((char2 & 0xC0) != 0x80)
throw new UTFDataFormatException(
"malformed input around byte " + count);
chararr[chararr_count++]=(char)(((c & 0x1F) < < 6) |
(char2 & 0x3F));
break;
case 14:
/* 1110 xxxx 10xx xxxx 10xx xxxx */
count += 3;
if (count > utflen)
throw new UTFDataFormatException(
"malformed input: partial character at end");
char2 = (int) bytearr[count-2];
char3 = (int) bytearr[count-1];
if (((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80))
throw new UTFDataFormatException(
"malformed input around byte " + (count-1));
chararr[chararr_count++]=(char)(((c & 0x0F) < < 12) |
((char2 & 0x3F) < < 6) |
((char3 & 0x3F) < < 0));
break;
default:
/* 10xx xxxx, 1111 xxxx */
throw new UTFDataFormatException(
"malformed input around byte " + count);
}
}
// The number of chars produced may be less than utflen
return new String(chararr, 0, chararr_count);
} Reads from the
stream in a representation
of a Unicode character string encoded in
modified UTF-8 format;
this string of characters is then returned as a String.
The details of the modified UTF-8 representation
are exactly the same as for the readUTF
method of DataInput. |
public final int readUnsignedByte() throws IOException {
int ch = in.read();
if (ch < 0)
throw new EOFException();
return ch;
} |
public final int readUnsignedShort() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (ch1 < < 8) + (ch2 < < 0);
} |
public final int skipBytes(int n) throws IOException {
int total = 0;
int cur = 0;
while ((total< n) && ((cur = (int) in.skip(n-total)) > 0)) {
total += cur;
}
return total;
} |
java.io.InputStream