Floating. Point. Numbers. Have. Limited. Precision. And. Are. Not.
Stored. As. Decimal. Values.

The result you report for this program matches the answer Andrew and I
got for the first program.

Java float and double each represent numbers in binary floating point.
Java float has, effectively, 24 significant bits, the equivalent of
about 7.2 decimal digits. You should expect rounding error in the 8th
significant decimal digit.

The rules are in the JLS, see
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3
the following section, and the sections they reference.

IEEE 32 bit float is almost always the wrong data type to use. It gives
up a lot of accuracy for halving the space required compared to double.
If you should be using a binary floating point type at all, you should
normally use double. The exception is if you are storing a large number
of values with low accuracy requirements, and have done the numerical
analysis to convince yourself that float is precise enough.

If you need the behavior you seem to expect, exact representation and
addition of decimal fractions, consider using BigDecimal.

Patricia

As a general rule, double gives a lot more precision than float, 53
significant bits instead of 24. However, the default Double.toString
conversion always produces enough decimal places to uniquely identify
the double value, so it can produce similar effects, just with longer
output. Of course, all of this is very dependent on the particular
numbers you pick.

If you strongly favor exact processing of decimal fractions, you should
use neither double nor float, but BigDecimal which is designed for that job.

Patricia

It "works" with float, too. It just doesn't work in the way that you
expect it to.

Computers use binary arithmetic. Some computers have used binary
arithmetic since the early 1950s, and nearly all computers have used
binary arithmetic since the mid 1960s. If you have taken any kind of
computer programming course at all, you should bring a lawsuit against
the fool of a teacher who did not instruct you in this.

Do you remember how, with decimal fractions, you discovered that 1/3 +
1/3 + 1/3 added up to 0.99 instead of 1? Well, with binary fractions,
you have the same problem where 1/10 or 1/100 is involved. But for
purposes of science and engineering, binary arithmetic is just as
effective as decimal arithmetic, and faster and cheaper. The world is
not carved up into exact decimal fractions. Distances between points are
not always an exact number of millimeters. Masses of objects are not
always an exact number of grams. Time intervals are not always an exact
number of milliseconds.

Money, on the other hand, /is/ carved up into exact decimal fractions.
Therefore, when you are working with money, you should use the Java
BigDecimal class, instead of float or double. Dollars are always an
exact number of cents. Euros are always an exact number of eurocents.
Pounds are always an exact number of new pence. The considerable loss of
time involved in using BigDecimal is unimportant, because the
calculations involving money are far less intensive than the complex
problems in calculus that come up in science and engineering.