Java IO.pdf - Nguyen Dang Binh

Java I/O
public abstract StringBuffer format(double number, StringBuffer toAppendTo,
FieldPosition pos)
public abstract StringBuffer format(long number, StringBuffer toAppendTo,
FieldPosition pos)
public abstract Number parse(String text, ParsePosition parsePosition)
The two format methods must format a long and a double respectively, update the
FieldPosition object with the locations of the different fields, append the formatted string
to the string buffer toAppendTo, and return that same string buffer. The parse() method
must read a number in scientific notation, convert it to a java.lang.Number (that is, a
java.lang.Long or a java.lang.Double) and return that.
The concrete formatting methods in NumberFormat all invoke these methods, so they may be
kept as is rather than being overridden. However, it would not hurt to override clone(),
hashCode(), and equals(). You could also add some additional methods to specify
formatting of the exponent. However, to keep this example reasonably compact, I'll assume
that the exponent is only as wide as it needs to be with either a + or a - prefix. This is large
enough to handle both the largest and the smallest double values in Java
(1.79769313486231570e+308 and 4.94065645841246544e-324, respectively).
A typical exponential number has three fields: the integer, the fraction, and the exponent. It
would be nice to define constants for these fields and use the FieldPosition object passed to
format() to identify the locations of these fields in the formatted output. Regrettably, the
java.text API does not provide adequate support for third-party formatting classes. The
FieldPosition set methods are "friendly"—that is, accessible only to other classes in the
same package—so our class can't use them.
void setBeginIndex(int bi)
void setEndIndex(int ei)
Similarly, there's no way to add extra field definitions, such as an exponent field. Therefore,
any user-created Format subclass will be crippled relative to the ones JavaSoft provides.
Example 16.9 shows the code for the ExponentialFormat class. There are at least three
different ways to parse and format exponential numbers. The simplest, and the one I've used
here, is to treat an exponential number as a combination of a decimal number plus the letter
"e" or "E" plus an integer. Then use DecimalFormat to format or parse those parts. It would
be slightly more efficient to do all formatting directly, but the benefits of code reuse more
than offset a small increase in efficiency. Internationalization comes for free, since the
DecimalFormat class handles internationalization. A DecimalFormat object for a given
locale may be passed to the constructor. Otherwise, the format for the default locale is
selected.
Example 16.9. ExponentialFormat
import java.text.*;
import java.io.*;
import java.util.*;
424