Java IO.pdf - Nguyen Dang Binh

for (double degrees = 0.0; degrees < 360.0; degrees++) {
y += lineHeight;
String degreeString = myFormat.format(degrees, new StringBuffer(),
fp).toString();
String intPart = degreeString.substring(0, fp.getEndIndex());
g.drawString(degreeString, xmargin + desiredPixelWidth
- fm.stringWidth(intPart), y);
String radianString = myFormat.format(Math.PI*degrees/180.0,
new StringBuffer(), fp).toString();
intPart = radianString.substring(0, fp.getEndIndex());
g.drawString(radianString,
xmargin + fieldWidth + desiredPixelWidth -
fm.stringWidth(intPart), y);
String gradString = myFormat.format(400 * degrees / 360,
new StringBuffer(), fp).toString();
intPart = gradString.substring(0, fp.getEndIndex());
g.drawString(gradString,
xmargin + 2*fieldWidth + desiredPixelWidth -
fm.stringWidth(intPart), y);
}
}
}
16.5 Parsing Input
Java I/O
Number formats also handle input. When used for input, a number format converts a string in
the appropriate format to a binary number, achieving more flexible conversions than you can
get with the methods in the type wrapper classes (like Integer.parseInt()). For instance, a
percent format parse() method can interpret 57% as 0.57 instead of 57. A currency format
can read (12.45) as -12.45.
There are three parse() methods in the NumberFormat class. All do roughly the same thing:
public Number parse(String text) throws ParseException
public abstract Number parse(String text, ParsePosition parsePosition)
public final Object parseObject(String source, ParsePosition parsePosition)
The first parse() method attempts to parse a number from the given text. If the text
represents an integer, it's returned as an instance of java.lang.Long. Otherwise, it's returned
as an instance of java.lang.Double. If a string contains multiple numbers, only the first one
is returned. For instance, if you parse "32 meters" you'll get the number 32 back. Java throws
away everything after the number finishes. If the text cannot be interpreted as a number in the
given format, a ParseException is thrown. The second parse() method specifies where in
the text parsing starts. The position is given by a ParsePosition object. This is a little more
complicated than using a simple int but does have the advantage of allowing one to read
successive numbers from the same string. The third parse() method merely invokes the
second. It's declared to return Object rather than Number so that it can override the method of
the same signature in java.text.Format. If you know you're working with a NumberFormat
rather than a DateFormat or some other nonnumeric format, there's no reason to use it.
The java.text.ParsePosition class has one constructor and two public methods:
public ParsePosition(int index)
public int getIndex()
public void setIndex(int index)
412