-1

I do not get what Oracle means by followings: It seems to me the first and second ones are the same, the hashcode of two equal objects should always be the same! And for the last one does that mean, lets say in the following code change the value of prime in other classes? 

1) Whenever it is invoked on the same object more than once during an 
   execution of a Java application, the hashCode method must consistently return 
   the same integer, provided no information used in equals comparisons on 
   the object is modified. This integer need not remain consistent from 
   one execution of an application to another execution of the same application.

2) If two objects are equal according to the equals(Object) method, then calling 
   the hashCode method on each of the two objects must produce the same integer result.

3) It is not required that if two objects are unequal according to the 
   Object.equals(java.lang.Object) method, then calling the hashCode method 
   on each of the two objects must produce distinct integer results. However, 
   the programmer should be aware that producing distinct integer results for 
   unequal objects may improve the performance of hash tables.

MyCode

public class Derived {
    private int myVar;

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + myVar;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Derived other = (Derived) obj;
        if (myVar != other.myVar)
            return false;
        return true;
    }

}
Jon Heller
  • 34,999
  • 6
  • 74
  • 132
Jack
  • 6,430
  • 27
  • 80
  • 151
  • @SotiriosDelimanolis thanks, I rephrased it. – Jack Oct 07 '14 at 01:12
  • If the objects are equal but hashCodes are different, it suggests that you didn't override hashCode properly. It's a roundabout way of saying "if you override equals, you must override hashCode". See Joshua Bloch "Effective Java" chapter 3. – duffymo Oct 07 '14 at 01:12
  • my understanding of these statements is [1] hashcode is the same if your object is the same (object is basically something with a state), [2] if 2 objects return true when equals() each other, then their hashcodes also must be the same [3] if 2 objects are not equals() each other, then not necessarily you have to return different hashcodes (since, I believe, the idea of a hashcode is to quickly return some object given some hash function, but of course no hash function is perfect so collisions may happen, so it's ok) – Leo Oct 07 '14 at 01:24

1 Answers1

0

In order for an object to function correctly in hash tables, it's important for the hashCode() function to return consistent values. In particular 2 logically equal values must have the same hashCode(), otherwise you'll see flakiness.

The reason is the way hash tables typically work. A common implementation is a single array of pointers to "buckets". To find an object, hashCode() is called, then a modulus is taken to find an index in this array. Once we find the index, we look in the bucket for the objects, perhaps testing == and equals() until hitting a match.

Let's say an object 'foo' is in the table with hashCode() 1234. Now we search for an object claiming to be 'foo' but its hashCode() is different. Very likely we'll look in the wrong bucket, thus we'll fail to find a match even if both objects return a true equals(). Likewise the table assumes the hash code is stable (immutable).

seand
  • 5,168
  • 1
  • 24
  • 37