将哈希码作为一个简单的增量可以吗？

Question

Is this code below okay for a hashCodeto be a simple increment starting with a negative number?

private volatile static AtomicInteger creations = new AtomicInteger(Integer.MIN_VALUE);
private final int creation;

{
    creation = creations.getAndIncrement();
}

@Override
public int hashCode() {
    return creation;
}

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    if (creation == ((Stuff) obj).creation)
        return true;
    else
        return false;
}

How come hashCodes are usually made with prime numbers instead of using just a simple increment? (The reason why I want it to be this way is because each object I create with this class will be unique and I want to be able to remove it from a HashMap later even though the state of the object will change, because it is my understanding if a Hash changes then you cannot remove it from a HashMap after it was added) To prevent this from being a simple yes or no answer, maybe explain to me the pros and cons of implementing a Hash this way.

Answer 1

In general it's not okay. Two objects for which object1.equals(object2) returns true must have the same hashCode .

However, in your specific case, where the only criteria for object equality is the creation property, which is the same property used in the hashCode , your hashCode is fine.

However, your hashCode and equals don't offer much benefit over the default implementations of Object , since a.equals(b) will be true if and only if a==b .

Answer 2

Yes it's ok (if two instances are equals, they have the same hashcode) although your equals/hashcode implementation is not doing much vs. the default implementation of Object so there is no point doing that - unless you want objects to be equal every 2^32 instance creation.

Based on your additions, I would agree with Patricia Shanahan's suggestion to use identityHashCode :

@Override
public int hashCode() {
  return System.identityHashCode(this);
}

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

That is essentially what Object does by default. In terms of collisions, I doubt that you will have more collision with this implementation than yours.