In JVM heap can there be more than one object with the same hash code?

Question

This is a an interview question.

Answer 1

yes, since you can have as many objects with the same hashCode as you want. For example, the following code, without interning Strings, show this fact:

String foo = new String("dfa");
String bar = new String("dfa");
assert foo != bar; // yields false, two distinct objects (references)
assert foo.hashCode() == bar.hashCode(); // yields true

Answer 2

Yes, hashcode is a standard algorithm that tries to avoid duplicates ('collisions') but doesn't guarantee it.

Moreover, it's overrideable, so you could write your own implementation yielding the same hashcode for every object; as to why you would want to do that I have no answer however. :-)

Answer 3

Yes.

public class MyObject {
    @Override
    public int hashCode() {
        return 42;
    }

    public static void main(String[] args) {
        MyObject obj1 = new MyObject();
        MyObject obj2 = new MyObject(); // Ta-da!
    }
}

For a less flippant answer, consider the hashCode Javadocs:

The general contract of hashCode is:

• ... (snip) ...
• 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.

Answer 4

in a 32-bit environment, I doubt any JVM would return same 'identity hash code' for different objects. but in 64-bit, that is certainly a possibility; the likelihood of collision is still very small given the limited memory we have now.

Answer 5

About hash codes: yes they are nearly, but not really unique. :) It depends on the implementation/theory how nearly unique they are.

But if we talk about the JVM, we must first of all talk about what kind of hash code you've meant.

If you talk about the result of the hashCode() method which is used f.e. by the HashMap, then the answer is: it depends on your implementation and the number of objects in your JVM.
It's your choice and plan and knowledge to resolve this conflict in a self-implemented hashCode() method.

If you talk about the result of the method System.identityHashCode( obj ), then it's a little bit different. This implementation doesn't call your hashCode() method. And the implementation isn't unique - but it's nearly unique, like many other different hash functions. :)

public class MyObject {
    @Override
    public int hashCode() {
        return 42;
    }

    public static void main(String[] args) {
        MyObject obj1 = new MyObject();
        MyObject obj2 = new MyObject(); // Ta-da!

        final int obj1Hash = System.identityHashCode( obj1 );
        final int obj2Hash = System.identityHashCode( obj2 );

        if( obj1Hash == obj2Hash ) throw new IllegalStateException();
    }
}

In this example you will get different hashes, and in the most cases they are different, but not definitely unique...

Best regards!

Answer 6

Trivial proof: hashCode returns a 32 bit integer.

Allocate 2^32+1 Objects. (Probably going to need a 64-bit VM and a lot of RAM for this! ;-) )

Now your hashCode method, no matter how clever, must have a collision.

Answer 7

Yes you certainly can have more than one object with the same hashcode. However, usually this doesn't cause problems because the java.util.* data structures that use the object hashcode use it as a key into a "bucket" that stores all objects returning the same hash.

Answer 8

You can, but it's not generally a good idea. The example mentioned several times above:

public int hashCode(){
     return 1;
}

is perfectly valid under the specification for hashCode(). However, doing this turns HashMap into a Linked List, which significantly degrades performance. So you generally want to implement hashCode to return values as unique as you can get it.

As a practical matter, though, collisions can occur with many implementations. Take this for example:

public class OrderedPair{
     private int x;
     private int y;

     public int hashCode(){
          int prime = 31;
          int result=x;
          result =result*prime+y;
          return result; 
     }

     public boolean equals(){...}
}

This is a pretty standard implementation of hashCode() (in fact, this is pretty close to the output which is automatically generated in IDEA and Eclipse), but it can have many collisions: x=1,y=0 and x=0,y=1 will work for starters. The idea of a well-written hashCode() implementation is to have few enough collisions that your performance is not unduly affected.

Answer 9

Of course, and obviously you can write:

class MyClass{
   ...
   public int hashCode(){
      return 1;
   }
   ...
}

in which case all instances of MyClass will have the same hash code.

Answer 10

Object a = new Integer(1);
Object b = new Integer(1);

System.out.printf(" Is the same object?     = %s\n",(a == b ));
System.out.printf(" Have the same hashCode? = %s\n",( a.hashCode() == b.hashCode() ));

Prints:

Is the same object?     = false
Have the same hashCode? = true