Should I use "equal" or "==" in this case?

Hi folks,

I am doing unit test on an getInstance() method of a singleton class.

I want to test two getInstance() calls are actually returning the same object.

Should i use equal or '==' to compare the two references?

And what are their differences?

Is "equal" method actually compare the hashcode of two objects in order to test their equality?

if you want to compare the two refernce to check whether they are equal or not then use ==.

but when you want to know whether the two objects are meaningfully equivalent then use equals.

in your case as you want to know whether two objects are equal or not then i recommend use equals

and also if two hashcode are equals then it doesnot means that object will be equal
it means they are in same bucket

For singleton instance '==' is what you should be using, since in case of objects it compares their location in memory.

Thank you all, folks.

By the way, Shanky Sohar, when you said "use equals to check whether two objects are meaningfully equal?"

what does that mean?

In other words, what is the inner implementation under equals method?

It depends on programmers opinion, or the innerworks of the program. For example if you mada a person class with all kinds of attributes, from name, height, age, skin tone, eye color, IQ etc. your equals method might take all of them into consideration or just name and surname.

== will work here, the equals method won't, and I'll tell you why:

== checks for identity, meaning it will only return true if the objects compared have the same address in memory

equals() checks for meaningful equivalency, meaning it will return true whenever the equals() method returns true. Those conditions depend on which implementation of equals() the developer of the first class you're comparing has used. There are rules for creating an appropriate equals class, but you don't always have a guarantee that the implemented equals() method is appropriate. Even if it were appropriate, it would probably only check if the contents are equal, which, if your method "getInstance()" say, returns a new instance for every call, would also result in true, which is definitely not what you want.

which means if you want to make sure it is returning the same item, and not an equivalent other instance, you must use ==.

I hope that is sufficient explanation.

Dieter Quickfend wrote:== will work here, the equals method won't, and I'll tell you why:

== checks for identity, meaning it will only return true if the objects compared have the same address in memory

equals() checks for meaningful equivalency, meaning it will return true whenever the equals() method returns true. Those conditions depend on which implementation of equals() the developer of the first class you're comparing has used. There are rules for creating an appropriate equals class, but you don't always have a guarantee that the implemented equals() method is appropriate. Even if it were appropriate, it would probably only check if the contents are equal, which, if your method "getInstance()" say, returns a new instance for every call, would also result in true, which is definitely not what you want.

which means if you want to make sure it is returning the same item, and not an equivalent other instance, you must use ==.

I hope that is sufficient explanation.

Martin Vanyavchich wrote:It depends on programmers opinion, or the innerworks of the program. For example if you mada a person class with all kinds of attributes, from name, height, age, skin tone, eye color, IQ etc. your equals method might take all of them into consideration or just name and surname.

Ok, i see, we should override equals() in order to give it more meaningful object comparision.

BUT what if i dont override the equals() method in my own class, what is the equals() actually doing?

What is it doing in order to decide to return true or false?

. . . and the equals() method in the class you are using should have documentation comments to describe how it works.

JavaDoc wrote:The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).

You can read the whole thing here

In my opinion you don't need an equals method for a Singleton class, since if it is properly implemented '==' should always return true.

If it's a JUnit test we're talking about why not simply use Assert.assertSame()?

I was going to say that.

Thanks everybody.

I learned a lot

You're welcome