Java IO.pdf - Nguyen Dang Binh

7.7 Miscellaneous Methods
Java I/O
The DataInputStream and DataOutputStream classes each have one method left to discuss,
skipBytes() and size(), respectively.
7.7.1 Determining the Number of Bytes Written
The DataOutputStream class has a protected field called written that stores the number of
bytes written to the output stream since it was constructed. The value of this field is returned
by the public size() method:
protected int written
public final int size()
Every time you invoke writeInt(), writeBytes(), writeUTF(), or some other write
method, the written field is incremented by the number of bytes written. This might be
useful if for some reason you're trying to limit the number of bytes you write. For instance,
you may prefer to open a new file when you reach some preset size rather than continuing to
write into a very large file.
7.7.2 Skipping Bytes in an Input Stream
The DataInputStream class's skipBytes() method skips over a specified number of bytes
without reading them. Unlike the skip() method of java.io.InputStream that
DataInputStream inherits, skipBytes() either skips over all the bytes it's asked to skip or it
throws an exception:
public final int skipBytes(int n) throws IOException
public long skip(long n) throws IOException
skipBytes() blocks and waits for more data until n bytes have been skipped (successful
execution) or an exception is thrown. The method returns the number of bytes skipped, which
is always n (because if it's not n , an exception is thrown and nothing is returned). On end of
stream, an EOFException is thrown. An IOException is thrown if the underlying stream
throws an IOException.
7.8 Reading and Writing Little-Endian Numbers
It's likely that at some point in time you'll need to read a file full of little-endian data,
especially if you're working on Intel hardware or with data written by native code on such a
platform. Java has essentially no support for little-endian numbers. The
LittleEndianOutputStream class in Example 7.8 and the LittleEndianInputStream class
in Example 7.9 provide the support you need to do this. These classes are closely modeled on
the java.io.DataInputStream and java.io.DataOutputStream classes. Some of the
methods in these classes do exactly the same thing as the same methods in the
DataInputStream and DataOutputStream classes. After all, a big-endian byte is no different
from a little-endian byte. In fact, these two classes come very close to implementing the
java.io.DataInput and java.io.DataOutput interfaces. Actually doing so would have
been a bad idea, however, because client programmers will expect objects implementing
111