Difference between double and Double in comparison

Question

I know that Double is a a wrapper class, and it wraps double number. Today, I have seen another main difference :

double a = 1.0;
double b = 1.0;
Double c = 1.0;
Double d = 1.0;
System.out.println(a == b);  // true
System.out.println(c == d);  // false

So strange with me !!!

So, if we use Double, each time, we must do something like this :

private static final double delta = 0.0001;
System.out.println(Math.abs(c-d) < delta); 

I cannot explain why Double make directly comparison wrong. Please explain for me.

Answer 1

Difference between == and equals

using == on primitive data types is not the same as using it on object reference data types.

1. On primitive data types == is used as equals.
2. for object reference data types == refers to their references. Thus what the object points to in memory.

Consider case 1

    double d1 = 10.00;
    double d2 =10.00;
    System.out.println(d1 == d2); 

*output is * true

case 2: == reference data types

    Double d1 = 10.00;
    Double d2 =10.00;
    System.out.println(d1 == d2);

*output is * false

d1 and d2 have different memory references.

to check the validity of this consider the following code

    Double d1 = 10.00;
    Double d2 = d1;
    System.out.println(d1 == d2);

This will print true since d1 and d2 point to the same memory reference.

Therefore

Java uses == to compare primitives and for checking if two variables refer to the same object

`equals'

is used for checking if two objects are equivalent.

it also depends on the implementation of the object it is being called on. For Strings, equals() checks the characters inside of it.

    Double d1 = 10.00;
    Double d2 = 10.00;
    System.out.println(d1.equals(d2));

prints true since it looks what's inside the d1 and d2.

case 1 will not compile

Answer 2

c and d are technically two different objects and == operator compares only references.

c.equals(d)

is better as it compares values, not references. But still not ideal. Comparing floating-point values directly should always take some error (epsilon) into account (Math.abs(c - d) < epsilon).

Note that:

Integer c = 1;
Integer d = 1;

here comparison would yield true, but that's more complicated (Integer internal caching, described in JavaDoc of Integer.valueOf()):

This method will always cache values in the range -128 to 127, inclusive, and may cache other values outside of this range.

Why valueOf()? Because this method is implicitly used to implement autoboxing:

Integer c = Integer.valueOf(1);
Integer d = Integer.valueOf(1);

See also

• Weird Integer boxing in Java
• How to properly compare two Integers in Java?

Answer 3

Content checking is only reliable for == when checking primitive types. For objects types it is always better to use the equals method:

c.equals(d)

Answer 4

When applied to expressions of a class type, == will always perform a reference comparison (JLS section 15.21.3). So this line:

System.out.println(c == d); 

is checking whether c and d refer to the same objects. Auto-boxing in Java always (I believe) creates a new object for float and double (the situation is more complicated for integral types¹). Therefore c and d refer to different objects, and so it prints false.

If you want to compare objects for equality, you need to call equals explicitly:

System.out.println(c.equals(d));

With double, it's using numeric equality instead - as specified in section 15.21.1. Hence the difference in behaviour.

---

¹ For integral autoboxing, "small" values are cached - so autoboxing 5 (say) will return the same reference every time. The definition of "small" is implementation-specific, but it's guaranteed within the range -128 to 127. See the bottom of section 5.1.7 for details.

Answer 5

Use equals() to checks the equality of 2 objects. == checks if the 2 references refer to the same object in the memory.