For-loop with double in Java

Question

Problem. I have a String of double "0.4 0.3 2.1 etc". I need to loop in this list and count occurencies of each number.

I used

StringTokenizer stokens = new StringTokenizer(values);
while(stokens.hasMoreTokens()) {
    Double tempKey = new Double(stokens.nextToken());
    Integer tempCount = orderValues.get(tempKey);
    if (tempCount == null) 
        tempCount = 1;
    else 
        tempCount++;
    orderValues.put(tempKey, tempCount);
}

where values is the string and orderValues is a TreeMap.

After this I have to add to the TreeMap all missing values from 0 to max key Value with a 0 occurency. So I use

for(double i = 0; i<=orderValues.lastKey(); i+=0.1) {
    if (orderValues.get(new Double(i))==null) {
        orderValues.put(i,0);
    }
}

The problem is the iteration on the double. I need to iterate just on the first decimal of double value. This is the output.

0.0 => 0
0.1 => 0
0.2 => 0
0.30000000000000004 => 0
0.4 => 0
0.5 => 1
0.6 => 1
0.7 => 0
0.7999999999999999 => 0
0.8999999999999999 => 0
0.9999999999999999 => 0
1.0999999999999999 => 0
1.2 => 2
1.3 => 0
1.4 => 2
1.4000000000000001 => 0
etc..

And of course it's a problem (look at 1.4 and 1.4000000001). How can I prevent this?

The main problem is iterate on double by 0.1 value

How I Fixed (thanks to Roel). I've changed the for statement into

for(double i = 0.1; i<=orderValues.lastKey(); i=rounding(0.1+i)) {

and added the rounding function

private double rounding(double x) {
    BigDecimal bd = new BigDecimal(x);
    bd = bd.setScale(1, RoundingMode.HALF_UP);
    return bd.doubleValue();
}

possible duplicate of [Is floating point math broken?](http://stackoverflow.com/questions/588004/is-floating-point-math-broken) — Dragondraikk, Jun 24 '15 at 09:12
On that note, it looks like you're using doubles as key values for a map, which is a bit tricky because of floating point arithmetics being as they are. Perhaps you may want to consider using a `BigDecimal` instead which would also solve your iteration problem. — Dragondraikk, Jun 24 '15 at 09:15

score 2 · Answer 1 · answered Jun 24 '15 at 09:19

2

You are using the primitive double and class type Double and there is a conversion going on between them and as they're both floating point you're seeing floating point imprecision.

answered Jun 24 '15 at 09:19

Oliver Hemsted

571
2
13

score 2 · Answer 2 · answered Jun 24 '15 at 09:25

The lack of precision of double types is well-known. Usually, a solution is to use BigDecimal instead. However in your specific case, since you're stepping 0.1 at each iteration, you could also work with integers, and divide them by 10 when needed.

Note that you should also change the way you store the data. That is, use:

TreeMap<BigDecimal, Integer>

(or TreeMap<Integer, Integer>) instead of TreeMap<Double, Integer>

See also the documentation of BigDecimal: http://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html It's not as easy to use as double, but much safer.

For-loop with double in Java

2 Answers2