java: memoizing construction through hash function

The purpose of a hash code is generally to narrow down the location in which to look for a particular object. Or put another way, the idea is that your hash code makes it so that if two objects have the same hash code they are "very likely" to be the same object.

Now, how likely is "very likely" essentially depends on the width (number of bits) and quality of the hash code. In the case of Java, with 32 bit hash codes, this "very likely" still generally means "not near enough to 100% that you can do away with an actual comparison of the object data". So as well as implementing hashCode(), you need to implement equals() on an object that is used as the key to a Java Map (HashMap etc).

Or put another way: your implementation is essentially correct, even though it looks like you're doing a lot of work. The upshot is that if what you are looking for is a performance improvement, you may as well just create a new object each time. But if functionally you require that there never exists more than one object with a given set of values, then your implementation is essentially correct.

Things you could do in principle:

• if you had a large number of ints, then for the hashCode(), just form the hash code from a 'sample' of a couple of them -- the idea is to 'narrow down the choices' or make it 'fairly but not 100% likely' that equal hash code will mean equal object-- your equals() has to go through and check them anyway, so there's little point in cycling through all values in both hashCode() and equals();
• potentially, you can use a stronger hash code, so that you literally assume that equal hash codes mean equal objects. In effect, you cycle through all of the values once in the hash code function and don't have an equals function at all. In practice this means using at least a strong-ish 64 bit hash code. It's probably not worth it for the case you mention. But if you want to understand a little about how it would work, I would point you to a tutorial I wrote on the advanced use of hash codes in Java.

If the 4 integers during construction mean the resulting object will be exactly the same, then use those as the key, not their hash. Notice I'm not using your full Object as the key, just the 4 integer values. The MyObjectSpecification below will be a tiny object.

public class MyObjectSpecification {
    private final int i1, i2, i3, i4;

    public MyObjectSpecification(int i1, int i2, int i3, int i4) {
        this.i1 = i1;
        this.i2 = i2;
        this.i3 = i3;
        this.i4 = i4;
    }

    public boolean equals(Object o) {
        // ...
    }

    public int hashCode() {
        // ...
    }
}

public class MyObject {
    private static final Map<MyObjectSpecification, MyObject> myObjects
            = new ConcurrentHashMap<MyObjectSpecification, MyObject>();

    private MyObject(MyObjectSpecification spec) {
        // ...
    }

    public static MyObject getMyObject(int i1, int i2, int i3, int i4) {
        MyObjectSpecification spec = new MyObjectSpecification(i1, i2, i3, i4);

        if (myObjects.containsKey(spec)) {
            return myObjects.get(spec);
        }

        MyObject newObject = new MyObject(spec);
        myObjects.put(spec, newObject);
        return newObject;
    }
}