Java IO.pdf - Nguyen Dang Binh

7.2.2 The Char Format
Java I/O
Unicode characters are two bytes long and are interpreted as an unsigned number between and
65,535. This means they have an "endianness" problem too. The Unicode standard
specifically does not require a particular endianness of text written in Unicode; both big- and
little-endian encodings are allowed. In my opinion, this is a failing of the specification. The
Unicode standard does suggest that character 65,279 (0xFEFF in hex) be placed at the
beginning of each file of Unicode text. Thus, by reading the first character, you can determine
the endianness of the file and take appropriate action. For example, if you're reading a
Unicode file containing little-endian data using big-endian methods, the first character will
appear as 0xFFFE (65,534), signaling that something is wrong. Java's data stream classes
always write and read Unicode text in a big-endian fashion.
7.2.3 Writing Integers
The DataOutputStream class has the usual three write() methods you'll find in any output
stream class:
public synchronized void write(int b) throws IOException
public synchronized void write(byte[] data) throws IOException
public synchronized void write(byte[] data, int offset, int length)
throws IOException
These behave exactly as they do in the superclass, so I won't discuss them further here.
The DataOutputStream class also declares the following void methods that write signed
integer types onto its underlying output stream:
public final void writeByte(int b) throws IOException
public final void writeShort(int s) throws IOException
public final void writeInt(int i) throws IOException
public final void writeLong(long l) throws IOException
Because Java doesn't fully support the byte or short types, the writeByte() and
writeShort() methods each take an int as an argument. The excess bytes in the int are
ignored before the byte or short is written. Thus writeByte() only writes the low-order
byte of its argument. The writeShort() method only writes the low-order two bytes of its
argument, higher-order byte first; that is, big-endian order. The writeInt() and
writeLong() methods write all the bytes of their arguments in big-endian order. These
methods can throw IOExceptions if the underlying stream throws an IOException.
Example 7.1 fills a file called 1000.dat with the integers between 1 and 1000. This filename is
used to construct a FileOutputStream. This stream is then chained to a DataOutputStream
whose writeInt() method writes the data into the file.
Example 7.1. One Thousand ints
import java.io.*;
public class File1000 {
100