It's useful for building compareTo (interface Comparable) and compare
(interface Comparator) methods when the comparison criterion is the
value of a double.

Patricia

Its generally a bad idea to compare floating point numbers for
equality, due to rounding errors, you will find situations where your
comparison fails unexpectedly.

They do different things.  == ensures you are pointing to the same
object.  Compare ensures two different objects contain the same value.

I'll answer that but for a start: you probably, as Daniel noted,
do *not* want to directly compare double.  At least, if you ask
the question, you probably do not know all the details involved.

You probably want to read this (and want to learn what an
epsilon, in this context, is):

http://docs.sun.com/source/806-3568/ncg_goldberg.html

Now to answer your question...

What are double1 and double2? Objects? Primitives? What Java version?
Can auto-boxing take place?

       final Double a = new Double( 0.1d );
       final Double b = new Double( 0.1d );
       System.out.println( "a == b ? " + (a == b) );
       System.out.println( "Double.compare(a,b) == 0: " +
(Double.compare(a,b) == 0) );
       final double c = 0.1d;
       final double d = 0.1d;
       System.out.println( "c == d ? " + (c == d) );
       System.out.println( "Double.compare(c,d) == 0: " +
(Double.compare(c,d) == 0) );

Will output:

a == b ? false
Double.compare(a,b) == 0: true
c == d ? true
Double.compare(c,d) == 0: true

When you compare a and b with == you're comparing the
references of the two objects.  As I specifically used
"new" to construct them, the JVM MUST (by the specs)
create two different objects. Hence a == b returns false
(the references are not pointing to the same object).

When you compare c and d with ==, you're comparing
primitives.

Now, a little more fun:

       final double e = 0.1d;
       final double f = 0.3d;
       final double g = 0.2d;
       final double h = f - g;   // we're substracting 0.2 to 0.3 or
are we?
       System.out.println( "h == e ? " + (h == e) );
       System.out.println( "e is " + e );
       System.out.println( "h is " + h );

will output:

h == e ? false
e is 0.1
h is 0.09999999999999998

And the fact Java actually does output "e is 0.1" is really
interesting (hint: just as most decimal numbers, it's
impossible to represent 0.1 using Java's floating point numbers).