When do I need to override equals and hashcode methods? [duplicate]

Answer 1

The default implementation of equals tests whether the variables reference the same object. If that's not what you want, then you need to override equals. When you override equals you generally need to override hashcode for the object to be usable in hash tables (or other data structures that make use of hash codes).

Answer 2

If I compare 2 instances of A without override the equals method, will I get expected result?

No. Since you have created two different instances explicitly.

Why? The default implementation of equals checks whether the two concerned objects point to the same memory location in java virtual memory (and this default behavior is defined in java.lang.Object.equals())

When do I need to override equals and hashcode methods?

The most common scenario when programmers override both equals() and hashcode() are if you need to use instances of the concerned class as

1. Keys in java.util.Map implementations
2. Values in java.util.Set implementations
3. You want to check equality of values between two different instances of the same class (overriding equals() is mandatory in this case, hashcode() is not - but is a good programming practice to)

General contract of equals and hashcode is :

if a1.equals(a2)
    it is mandatory that a1.hashcode() == a2.hashcode()
if a1.hashcode() == a2.hashcode()
    it is not mandatory that a1.equals(a2)

I guess that enough data to process for a day :)

Answer 3

If I compare 2 instances of A without override the equals method, will I get expected result?

That depends on what you expect :)

The default implementation will give you reference equality - in other words, when you compare two references, equals will only return true if they're references to the same object.

You would normally override equals to implement "value equality" - where two distinct objects are deemed equal, usually by virtue of having equal field values themselves. The exact meaning of equality will depend on your design - the two objects could still be distinguishable in other ways, for example.

If you override equals, you should also override hashCode to be consistent with equals, such that if a.equals(b) is true, then a.hashCode() == b.hashCode(). This will allow instances of your class to be used as keys in hash-based collections (e.g. HashMap) so that you can look up a value based on a key which is equal to the original one, rather than having to use a reference to the exact original key object.