Java IO.pdf - Nguyen Dang Binh

Java I/O
For the most part, these classes have methods that are extremely similar to the equivalent
stream classes. Often the only difference is that a byte in the signature of a stream method is
replaced by a char in the signature of the matching reader or writer method. For example, the
java.io.OutputStream class declares these three write() methods:
public abstract void write(int i) throws IOException
public void write(byte[] data) throws IOException
public void write(byte[] data, int offset, int length) throws IOException
The java.io.Writer class, therefore, declares these three write() methods:
public void write(int i) throws IOException
public void write(char[] data) throws IOException
public abstract void write(char[] data, int offset, int length) throws
IOException
As you can see, the six signatures are identical except that in the latter two methods the byte
array data has changed to a char array. There's also a less obvious difference not reflected in
the signature. While the int passed to the OutputStream write() method is reduced modulo
256 before being output, the int passed to the Writer write() method is reduced modulo
65,536. This reflects the different ranges of chars and bytes.
java.io.Writer also has two more write() methods that take their data from a string:
public void write(String s) throws IOException
public void write(String s, int offset, int length) throws IOException
Because streams don't know how to deal with character-based data, there are no
corresponding methods in the java.io.OutputStream class.
1.5 The Ubiquitous IOException
As computer operations go, input and output are unreliable. They are subject to problems
completely outside the programmer's control. Disks can develop bad sectors while a file is
being read; construction workers drop backhoes through the cables that connect your WAN;
users unexpectedly cancel their input; telephone repair crews shut off your modem line while
trying to repair someone else's. (This last one actually happened to me while writing this
chapter. My modem kept dropping the connection and then not getting a dial tone; I had to
hunt down the telephone "repairman" in my building's basement and explain to him that he
was working on the wrong line.)
Because of these potential problems and many more, almost every method that performs input
or output is declared to throw IOException. IOException is a checked exception, so you
must either declare that your methods throw it or enclose the call that can throw it in a
try/catch block. The only real exceptions to this rule are the PrintStream and PrintWriter
classes. Because it would be inconvenient to wrap a try/catch block around each call to
System.out.println(), Sun decided to have PrintStream (and later PrintWriter) catch
and eat any exceptions thrown inside a print() or println() method. If you do want to
check for exceptions inside a print() or println() method, you can call checkError():
public boolean checkError()
25