比较 double 和 Double 之间的区别

Question

I know that Double is aa 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

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 2

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 3

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

Answer 4

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 5

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