Lazy initialization of hashcode in Java

Question

Why do we say that immutable objects use lazy hash code initialization? For mutable objects too, we can calculate hashcode only when required right causing lazy initialization?

Answer 1

For mutable classes, it usually doesn't make much sense to store the hashCode, as you'd have to update it every time the object is modified (or at least nullify it so you can recalculate it next time hashCode() is called).

For immutable classes, it makes a lot of sense to store the hash code - once it's calculated, it will never change (since the object is immutable), and there's no need to keep re-calculating every time hashCode() is called. As a further optimization, we can avoid calculating this value until the first time it's needed (ie, hashCode() is called) - ie, use lazy initialization.

There's nothing that prohibits you from doing the same on a mutable object, it's just generally not a very good idea.

Answer 2

The advantage of lazy initialization is that hashcode computation is suspended until it is required. Many objects don't need it at all, so you save some computations. Particularly when you have high hash computations. Look at the example below :

 class FinalObject { private final int a, b; public FinalObject(int value1, int value2) { a = value1; b = value2; } // not calculated at the beginning - lazy once required private int hashCode; @Override public int hashCode() { int h = hashCode; // read if (h == 0) { h = a + b; // calculation hashCode = h; // write } return h; // return local variable instead of second read } }