Java IO.pdf - Nguyen Dang Binh

Java I/O
character set was invented. Unicode is a 2-byte, 16-bit character set with 2 16 or 65,536
different possible characters. (Only about 40,000 are used in practice, the rest being reserved
for future expansion.) Unicode can handle most of the world's living languages and a number
of dead ones as well.
The first 256 characters of Unicode—that is, the characters whose high-order byte is zero—
are identical to the characters of the ISO Latin-1 character set. Thus 65 is ASCII A and
Unicode A; 66 is ASCII B and Unicode B and so on.
Java streams do not do a good job of reading Unicode text. (This is why readers and writers
were added in Java 1.1.) Streams generally read a byte at a time, but each Unicode character
occupies two bytes. Thus, to read a Unicode character, you multiply the first byte read by 256,
add it to the second byte read, and cast the result to a char. For example:
int b1 = in.read();
int b2 = in.read();
char c = (char) (b1*256 + b2);
You must be careful to ensure that you don't inadvertently read the last byte of one character
and the first byte of the next, instead. Thus, for the most part, when reading text encoded in
Unicode or any other format, you should use a reader rather than an input stream. Readers
handle the conversion of bytes in one character set to Java chars without any extra effort. For
similar reasons, you should use a writer rather than an output stream to write text.
1.3.4 UTF-8
Unicode is a relatively inefficient encoding when most of your text consists of ASCII
characters. Every character requires the same number of bytes—two—even though some
characters are used much more frequently than others. A more efficient encoding would use
fewer bits for the more common characters. This is what UTF-8 does.
In UTF-8 the ASCII alphabet is encoded using a single byte, just as in ASCII. The next 1,919
characters are encoded in two bytes. The remaining Unicode characters are encoded in three
bytes. However, since these three-byte characters are relatively uncommon, [1] especially in
English text, the savings achieved by encoding ASCII in a single byte more than makes up for
it.
Java's .class files use UTF-8 internally to store string literals. Data input streams and data
output streams also read and write strings in UTF-8. However, this is all hidden from direct
view of the programmer, unless perhaps you're trying to write a Java compiler or parse output
of a data stream without using the DataInputStream class.
1.3.4.1 Other encodings
ASCII, ISO Latin-1, and Unicode are hardly the only character sets in common use, though
they are the ones handled most directly by Java. There are many other character sets, both that
encode different scripts and that encode the same scripts in different ways. For example, IBM
mainframes have long used a non-ASCII eight-bit character set called EBCDIC. EBCDIC has
most of the same characters as ASCII but assigns them to different numbers. Macintoshes
1 The vast majority of the characters above 2047 are the pictograms used for Chinese, Japanese, and Korean.
22