Java IO.pdf - Nguyen Dang Binh

}
* possible that this number is temporarily less than the actual
* number of bytes written.)
* @return the value of the written field.
* @see java.io.LittleEndianOutputStream#written
*/
public int size() {
return this.written;
}
Java I/O
Notice how all writing is done by passing byte values to the underlying output stream out (set
in the constructor and inherited from the superclass, FilterOutputStream). The primary
purpose of these methods is to convert the Java data type to bytes and then write them in a
little-endian order. In general, the conversions are accomplished by shifting the bits of interest
into the low-order eight bits, then masking off the bits of interest. For example, consider the
writeInt() method:
public void writeInt(int i) throws IOException {
}
out.write(i & 0xFF);
out.write((i >>> 8) & 0xFF);
out.write((i >>> 16) & 0xFF);
out.write((i >>> 24) & 0xFF);
written += 4;
A Java int is composed of four bytes in big-endian order. Thus, the low-order byte is in the
last eight bits. This byte needs to be written first in a little-endian scheme. The mask 0xFF has
one bit in the low-order eight bits and zero bits everywhere else. By bitwise ANDing 0xFF
with i, we select the low-order eight bits of i. The second-lowest-order byte—that is, bits 16
to 23—is selected by first shifting the bits right without sign extension into the low-order bits.
That's the purpose of (i >>> 8). Then this byte can be retrieved with the same 0xFF mask used
before. The same is done for the second-to-lowest-order byte and the highest-order byte.
Here, however, it's necessary to shift by 16 and 24 bits, respectively.
floats and doubles are converted to ints and longs using Float.floatToIntBits() and
Double.doubleTolongBits(), then invoking writeInt() or writeLong() to write those
bits in little-endian order.
Each method increments the protected field written by the number of bytes actually written.
This tracks the total number of bytes written onto the output stream at any one time. This
incurs a surprising amount of overhead. If this class did not track the number of bytes written,
it could be several methods shorter. Furthermore, there is a potential synchronization problem,
which happens to be shared by DataOutputStream. It is possible for one thread to interrupt a
method like writeInt() after it has written some data but before the written field has been
updated. It would be simple to fix this problem by declaring all methods that update written
as synchronized. However, that would be a huge performance hit, so I've elected to follow
the example of DataOutputStream and not synchronize these methods.
Example 7.9 is the corresponding LittleEndianInputStream class, based on the
DataInputStream class.
117