As Far As I am Concern,They both differ very much in their significance. equals() method is present in the java.lang.Object class and it is expected to check for the equivalence of the state of objects! That means, the contents of the objects. Whereas the '==' operator is expected to check the actual object instances are same or not.

For example, lets say, you have two String objects and they are being pointed by two different reference variables s1 and s2.


s1 = new String("abc");
s2 = new String("abc");

Now, if you use the "equals()" method to check for their equivalence as


if(s1.equals(s2))
Sys tem.o ut.println("s1.equals( s2) is TRUE");
else
System.out.prin tln(" s1.equals( s2) is FALSE");

You will get the output as TRUE as the 'equals()' method check for the content equivality.

Lets check the '==' operator..


if(s1==s2)
Sy stem. out.printlln("s1==s2 is TRUE");
else
System.out.prin tln(" s1==s2 is FALSE");

Now you will get the FALSE as output because both s1 and s2 are pointing to two different objects even though both of them share the same string content. It is because of 'new String()' everytime a new object is created.

Answered by Sharad Singh , an ibibo Master, at 7:43 PM on September 03, 2008

The difference between == and object.Equals are given below-

For value types, == and Equals() usually compare two objects by value. For example:

int x = 10;
int y = 10;
Console.WriteLine( x == y );
Console.WriteLine( x.Equals(y) );

will display:

True
True

Howe ver things are more complex for reference types.

Generally speaking, for reference types == is expected to perform an identity comparison, i.e. it will only return true if both references point to the same object. By contrast, Equals() is expected to perform a value comparison,

i.e. it will return true if the references point to objects that are equivalent. For example:

StringBuilder s1 = new StringBuilder("fred");
String Build er s2 = new StringBuilder("fred");
Consol e.Wri teLine( s1 == s2 );
Console.WriteLine( s1.Equals(s2) );

will display:

False
True

s1 and s2 are different objects (hence == returns false), but they are equivalent (hence Equals() returns true).

Unfortunately there are exceptions to these rules. The implementation of Equals() in System.

Object (the one you'll inherit by default if you write a class) compares identity, i.e. it's the same as operator==. So Equals() only tests for equivalence if the class author overrides the method (and implements it correctly).

Another exception is the string class - its operator== compares value rather than identity.

Bottom line: If you want to perform an identity comparison use the ReferenceEquals() method.

If you want to perform a value comparison, use Equals() but be aware that it will only work if the type has overridden the default implementation.

Avoid operator== with reference types (except perhaps strings), as it's simply too ambiguous.

Answered by Madhurima , an ibibo Master, at 2:17 PM on September 02, 2008

They both differ very much in their significance. equals() method is present in the java.lang.Object class and it is expected to check for the equivalence of the state of objects! That means, the contents of the objects. Whereas the '==' operator is expected to check the actual object instances are same or not.

For example, lets say, you have two String objects and they are being pointed by two different reference variables s1 and s2.


s1 = new String("abc");
s2 = new String("abc");

Now, if you use the "equals()" method to check for their equivalence as


if(s1.equals(s2))
System.o ut.println("s1.equals( s2) is TRUE");
else
System.out.println(" s1.equals( s2) is FALSE");

You will get the output as TRUE as the 'equals()' method check for the content equivality.

Lets check the '==' operator..


if(s1==s2)
System. out.printlln("s1==s2 is TRUE");
else
System.out.println(" s1==s2 is FALSE");

Now you will get the FALSE as output because both s1 and s2 are pointing to two different objects even though both of them share the same string content. It is because of 'new String()' everytime a new object is created.

Answered by Reeta K , an ibibo Master, at 4:28 PM on September 01, 2008

For value types, == and Equals() usually compare two objects by value. For example:
int x = 10;
int y = 10;
Console.WriteLine( x == y );
Console.WriteLine( x.Equals(y) );
will display:
True
True
However things are more complex for reference types. Generally speaking, for reference types == is expected to perform an identity comparison, i.e. it will only return true if both references point to the same object. By contrast, Equals() is expected to perform a value comparison, i.e. it will return true if the references point to objects that are equivalent. For example:
StringBuilder s1 = new StringBuilder("fred");
String Builder s2 = new StringBuilder("fred");
Consol e.WriteLine( s1 == s2 );
Console.WriteLine( s1.Equals(s2) );
will display:
False
True
s1 and s2 are different objects (hence == returns false), but they are equivalent (hence Equals() returns true).
Unfortunately there are exceptions to these rules. The implementation of Equals() in System.Object (the one you'll inherit by default if you write a class) compares identity, i.e. it's the same as operator==. So Equals() only tests for equivalence if the class author overrides the method (and implements it correctly). Another exception is the string class - its operator== compares value rather than identity.
Bottom line: If you want to perform an identity comparison use the ReferenceEquals() method. If you want to perform a value comparison, use Equals() but be aware that it will only work if the type has overridden the default implementation. Avoid operator== with reference types (except perhaps strings), as it's simply too ambiguous.

Answered by Shobhit , an ibibo Master, at 4:48 PM on August 28, 2008

The difference between == and object.Equals are given below-

For value types, == and Equals() usually compare two objects by value. For example:

int x = 10;
int y = 10;
Console.WriteLine( x == y );
Console.WriteLine( x.Equals(y) );

will display:

True
True

Howe ver things are more complex for reference types.

Generally speaking, for reference types == is expected to perform an identity comparison, i.e. it will only return true if both references point to the same object. By contrast, Equals() is expected to perform a value comparison,

i.e. it will return true if the references point to objects that are equivalent. For example:

StringBuilder s1 = new StringBuilder("fred");
String Build er s2 = new StringBuilder("fred");
Consol e.Wri teLine( s1 == s2 );
Console.WriteLine( s1.Equals(s2) );

will display:

False
True

s1 and s2 are different objects (hence == returns false), but they are equivalent (hence Equals() returns true).

Unfortunately there are exceptions to these rules. The implementation of Equals() in System.

Object (the one you'll inherit by default if you write a class) compares identity, i.e. it's the same as operator==. So Equals() only tests for equivalence if the class author overrides the method (and implements it correctly).

Another exception is the string class - its operator== compares value rather than identity.

Bottom line: If you want to perform an identity comparison use the ReferenceEquals() method.

If you want to perform a value comparison, use Equals() but be aware that it will only work if the type has overridden the default implementation.

Avoid operator== with reference types (except perhaps strings), as it's simply too ambiguous.

Answered by Anju D , an ibibo Master, at 4:41 PM on August 26, 2008

For value types, == and Equals() usually compare two objects by value. For example:
int x = 10;
int y = 10;
Console.WriteLine( x == y );
Console.WriteLine( x.Equals(y) );
will display:
True
True
However things are more complex for reference types. Generally speaking, for reference types == is expected to perform an identity comparison, i.e. it will only return true if both references point to the same object. By contrast, Equals() is expected to perform a value comparison, i.e. it will return true if the references point to objects that are equivalent. For example:
StringBuilder s1 = new StringBuilder("fred");
String Builder s2 = new StringBuilder("fred");
Consol e.WriteLine( s1 == s2 );
Console.WriteLine( s1.Equals(s2) );
will display:
False
True
s1 and s2 are different objects (hence == returns false), but they are equivalent (hence Equals() returns true).
Unfortunately there are exceptions to these rules. The implementation of Equals() in System.Object (the one you'll inherit by default if you write a class) compares identity, i.e. it's the same as operator==. So Equals() only tests for equivalence if the class author overrides the method (and implements it correctly). Another exception is the string class - its operator== compares value rather than identity.
Bottom line: If you want to perform an identity comparison use the ReferenceEquals() method. If you want to perform a value comparison, use Equals() but be aware that it will only work if the type has overridden the default implementation. Avoid operator== with reference types (except perhaps strings), as it's simply too ambiguous.

Answered by jaivir , an ibibo Master, at 5:53 PM on August 14, 2008

I know the difference between == operator (which compares references) and equals() method (which compares the instance values).

But, surprisingly I found in the source code of our Object class in the equals() methods implementation that its also using the same == operator to compare. Am pasting the exact implementation.

public boolean equals(Object obj) {
return (this == obj);
}

Answered by Nagendra , an ibibo Master, at 8:58 PM on August 13, 2008

They both differ very much in their significance. equals() method is present in the java.lang.Object class and it is expected to check for the equivalence of the state of objects! That means, the contents of the objects. Whereas the '==' operator is expected to check the actual object instances are same or not.

For example, lets say, you have two String objects and they are being pointed by two different reference variables s1 and s2.


s1 = new String("abc");
s2 = new String("abc");

Now, if you use the "equals()" method to check for their equivalence as


if(s1.equals(s2))
System.out.println("s1.equals( s2) is TRUE");
else
System.out.println("s1.equals( s2) is FALSE");

You will get the output as TRUE as the 'equals()' method check for the content equivality.

Lets check the '==' operator..


if(s1==s2)
System.out.printlln("s1==s2 is TRUE");
else
System.out.println("s1==s2 is FALSE");

Now you will get the FALSE as output because both s1 and s2 are pointing to two different objects even though both of them share the same string content. It is because of 'new String()' everytime a new object is created.

Answered by Ashish Yadav , an ibibo Wizard, at 6:46 PM on August 13, 2008

They both differ very much in their significance. equals() method is present in the java.lang.Object class and it is expected to check for the equivalence of the state of objects! That means, the contents of the objects. Whereas the '==' operator is expected to check the actual object instances are same or not.

For example, lets say, you have two String objects and they are being pointed by two different reference variables s1 and s2.


s1 = new String("abc");
s2 = new String("abc");

Now, if you use the "equals()" method to check for their equivalence as


if(s1.equals(s2))
System.out.println("s1.equals( s2) is TRUE");
else
System.out.println("s1.equals( s2) is FALSE");

You will get the output as TRUE as the 'equals()' method check for the content equivality.

Lets check the '==' operator..


if(s1==s2)
System.out.printlln("s1==s2 is TRUE");
else
System.out.println("s1==s2 is FALSE");

Now you will get the FALSE as output because both s1 and s2 are pointing to two different objects even though both of them share the same string content. It is because of 'new String()' everytime a new object is created.

Try running the program without 'new String' and just with


String s1 = "abc";
String s2 = "abc";

You will get TRUE for both the tests.

Explanation : 2

By definintion, the objects are all created on the heap. When you create an object, say,


Object ob1 = new SomeObject();
Object ob2 = new SomeObject();

We have 2 objects with exactly the same contents, lets assume. We also have 2 references, lets say ob1 is at address 0x1234 and ob2 is at address 0x2345. Though the contents of the objects are the same, the references differ.

Using == compares the references. Though the objects, ob1 and ob2 are same internally, they differ on using this operation as we comare references. ob1 at address 0x1234 is compared with ob2 at address 0x2345. Hence, this comparison would fail.

object.equals() on the other hand compares the values. Hence, the comparison between ob1 and ob2 would pass. Note that the equals method should be explicitly overridden for this comparison to succeed.

Answered by shaista , an ibibo Master, at 2:37 PM on August 13, 2008

Well, They both differ very much in their significance. equals() method is present in the java.lang.Object class and it is expected to check for the equivalence of the state of objects! That means, the contents of the objects. Whereas the '==' operator is expected to check the actual object instances are same or not.

For example, lets say, you have two String objects and they are being pointed by two different reference variables s1 and s2.


s1 = new String("abc");
s2 = new String("abc");

Now, if you use the "equals()" method to check for their equivalence as


if(s1.equals(s2))
System.out.println("s1.equals(s2) is TRUE");
else
System.out.println("s1.equals(s2) is FALSE");

You will get the output as TRUE as the 'equals()' method check for the content equivality.

Lets check the '==' operator..


if(s1==s2)
System.out.printlln("s1==s2 is TRUE");
else
System.out.println("s1==s2 is FALSE");

Now you will get the FALSE as output because both s1 and s2 are pointing to two different objects even though both of them share the same string content. It is because of 'new String()' everytime a new object is created.

Try running the program without 'new String' and just with


String s1 = "abc";
String s2 = "abc";

You will get TRUE for both the tests.

For more details , Please visit the source site :

http://www.javabeat.net/qna/13 -what-is-difference-between-equals- and-/

Answered by Alok Gupta , an ibibo Guru, at 9:59 AM on August 13, 2008