comparisons

See also instanceof, interning, equals(...)

■ To test if an object belongs to a class (or to one of its superclasses), to an interface, or whether it is an Array, use instanceof. i.e.

String s = "S";

if ( s instanceof Object ) is true.

if ( s instanceof String ) is true.

■ To test if two object references point to the same object or if an object reference is null, use == (double equals).

For object references, != means does not point to the same object. i.e.

String s1 = "S";

String s2 = "T";

if ( s1 == s2 ) is false.

. . . .

String s1 = "S";

String s2 = "T";

if ( s1 != s2 ) is true.

. . . .

String s1 = null;

if ( s1 == null ) is true.

■ Remember that the toString( ) method always creates a new object. i.e.

if ( samething.toString( ) == samething.toString( ) ) will always be false because they’re always different objects.

■ The == operator doesn’t differentiate between floating point's primitive positive zero, normal zero, or negative zero. i.e.

if ( –0.0 == +0.0 ) is true. So are any other == comparisons between 0.0. +0.0, and -0.0.

■ For objects only, use object.equals( anotherobject ) to see if the actual contents of two objects match.

■ You cannot use == to compare objects of different types, as a compile error will result. i.e.

String s1 = "S";

Character c1 = new Character( 'S' );

if ( s1 == c1 ) System.out.print( "True" ); will not compile.

■ To test if two objects are of the same class type (or supertype) use Object’s getClass( ) method with == . The getClass( ) method returns a Class object. i.e.

if (object1.getClass( ) == object2.getClass( )) then do something.

.equals(...) method

■ Compare objects. equals(...) does a byte-by-byte comparison on contents, ignoring the object's location. It is the opposite of == , which ignores contents and compares location pointers.

■ Unless you override the equals(...) method in an object's class, equals(...) is the same as == , which compares just pointers, not contents. Without an override you will default to using the equals(...) method from Object, which does just a == comparison. The wrappers and collections classes, plus String, all override equals(...) so they provide actual content comparisons.

■ You cannot use equals(...) for primitives or literals. i.e.

Double D = new Double( 5 );

if ( D.equals( 5 ) ) will not compile due to the literal 5.

Double D = new Double( 5 );

int d = 5;

if ( D.equals( d ) ) will not compile due to the presence of the primitive d.

■ You cannot get true results on objects of different types using equals(...). It is only for objects of the same type. i.e.

Character C = new Character( 'A' );

Object O = new StringBuffer( "A" );

String S = "A";

if ( C.equals( O ) ) is false

if ( S.equals( C ) ) is false

if ( S.equals( O ) ) is false

■ You cannot use equals(...) between different wrapper types as it will always returns a false. i.e.

Double D = new Double ( 2.0 );

Float F = new Float( 2.0 );

if (D.equals( F) ) is false due to different object types

■ You cannot use equals(...) for StringBuffer, as StringBuffer does not provide an override. i.e.

StringBuffer s1 = new StringBuffer( "ABC" );

StringBuffer s2 = new StringBuffer( "ABC" );

if ( s1.equals(s2) ) is false

However...

String s1 = new String( "ABC" );

String s2 = new String( "ABC" );

if ( s1.equals( s2 ) ) is true

■ You cannot ever check an object for null with equals(...).

That’s because with null there's no actual null object to which to compare.

You must say if (obj == null) instead. i.e.

if ( object.equals( null ) ) runs and it returns false if the object is real.

But it gives a NullPointerException if the object in question was actually null.

■ Unlike the == operator, the equals(...) method treats two wrapper NaNs as equal. i.e.

Float F1 = new Float( Float.NaN );

Float F2 = new Float( Float.NaN );

if ( F1.equals( F2 ) ) returns true

if ( F1 == F2 ) ) returns false

■ Unlike the == operator, which treats all manners of floating point zeroes as unequal, equals(...) treats wrapper contents of floating point +0.0 as equal to 0.0. i.e.

In wrappers:	= = returns	equals(...) returns
+0.0 to 0.0	unequal	equal
+0.0 to -0.0	unequal	unequal
0.0 to -0.0	unequal	unequal