Why HashSet differentiates 0.0 and -0.0

Question

When I tried this:

HashSet<Double> set = new HashSet<>();
Double d1 = new Double(0);
Double d2 = new Double(0);
Double d3 = new Double(-0);
set.add(d1);
System.out.println(set.contains(d2));
System.out.println(set.contains(d3));

The output was what I expected:

true
true

But when I tried:

HashSet<Double> set = new HashSet<>();
Double d1 = new Double(0.0);
Double d2 = new Double(0.0);
Double d3 = new Double(-0.0);
set.add(d1);
System.out.println(set.contains(d2));
System.out.println(set.contains(d3));

or

set.add(Double.valueOf(d1));
System.out.println(set.contains(Double.valueOf(d2)));
System.out.println(set.contains(Double.valueOf(d3)));

To my surprise, the output was:

true
false

Why this happened? How do I make HashSet treat (0.0) and (-0.0) the same? Is there a better way than if(num == -0.0) num = 0.0;?

Comparing floating point values using == is indeed dangerous. Don't do it. — ncmathsadist, Mar 21 '16 at 01:02
You need a closeEnough() method for comparing doubles. What is your error tolerance. Belly up to the bar and say so. — ncmathsadist, Mar 21 '16 at 01:49
@ncmathsadist: Comparing floating-point values with `==` has well-defined, easily-understood semantics. It is not "dangerous." — tmyklebu, Mar 21 '16 at 03:58
@tmyklebu But there a very few cases where == on doubles really makes sense. Often it is a bug. — J Fabian Meier, May 19 '16 at 18:53

resueman · Accepted Answer · 2016-03-21T00:55:03.990

This is explained by the docs for Double.

If d1 represents +0.0 while d2 represents -0.0, or vice versa, the equal test has the value false, even though +0.0==-0.0 has the value true.

So a Double created from 0.0 is not the same as a Double created from -0.0. The same is not true when you use 0 and -0 because integers use twos-complement, which has no notion of negative zero. -0 is the same as 0. doubles, on the other hand, use the IEEE standard for floating point values, which does recognize a negative zero value.

This behavior is all fixed, so there's no way to have a HashSet treat 0.0 and -0.0 as the same. If you want to do that, you'll need to manually convert all negative zero values into positive zeros before adding or searching for them.

score 2 · Answer 2 · edited May 23 '17 at 12:23

-0.0 is a literal for a double value that is distinct from 0.0.

-0 is the negation operator applied to the int value 0, which gives just the int value 0.

Therefore, new Double(-0) is equivalent to new Double(0), whereas new Double(-0.0) and new Double(0.0) actually produce two non-equal Double objects.

See this question for some explanations for why it is necessary to have two different floating point zero values.

thst · Answer 3 · 2016-03-21T07:40:44.600

As explained in Wikipedia (thanks), the IEEE format for floating point actually supports negative and positive zeros for various reasons. https://en.wikipedia.org/wiki/Signed_zero

The reason why you find the 0.0 and -0.0 different in your hashmap is directly derived from the IEEE representation. The Double#hashCode method uses the raw bits of the floating point number to calculate the hashcode. Since 0.0 and -0.0 and possibly even +0.0 are different in terms of bits, as some numerical calculations obviously require this, their bits are different and therefore the hashcodes.

Why HashSet differentiates 0.0 and -0.0

3 Answers3