# Best implementation for hashCode method for a collection

Although this is linked to `Android` documentation (Wayback Machine) and My own code on Github, it will work for Java in general. My answer is an extension of dmeister’s Answer with just code that is much easier to read and understand.

``````@Override
public int hashCode() {

int result = 17;

// Include a hash for each field.

// Primatives

result = 31 * result + (booleanField ? 1 : 0);                   // 1 bit   » 32-bit

result = 31 * result + byteField;                                // 8 bits  » 32-bit
result = 31 * result + charField;                                // 16 bits » 32-bit
result = 31 * result + shortField;                               // 16 bits » 32-bit
result = 31 * result + intField;                                 // 32 bits » 32-bit

result = 31 * result + (int)(longField ^ (longField >>> 32));    // 64 bits » 32-bit

result = 31 * result + Float.floatToIntBits(floatField);         // 32 bits » 32-bit

long doubleFieldBits = Double.doubleToLongBits(doubleField);     // 64 bits (double) » 64-bit (long) » 32-bit (int)
result = 31 * result + (int)(doubleFieldBits ^ (doubleFieldBits >>> 32));

// Objects

result = 31 * result + Arrays.hashCode(arrayField);              // var bits » 32-bit

result = 31 * result + referenceField.hashCode();                // var bits » 32-bit (non-nullable)
result = 31 * result +                                           // var bits » 32-bit (nullable)
(nullableReferenceField == null
? 0
: nullableReferenceField.hashCode());

return result;

}
``````

EDIT

Typically, when you override `hashcode(...)`, you also want to override `equals(...)`. So for those that will or has already implemented `equals`, here is a good reference from my Github…

``````@Override
public boolean equals(Object o) {

// Optimization (not required).
if (this == o) {
return true;
}

// Return false if the other object has the wrong type, interface, or is null.
if (!(o instanceof MyType)) {
return false;
}

MyType lhs = (MyType) o; // lhs means "left hand side"

// Primitive fields
return     booleanField == lhs.booleanField
&& byteField    == lhs.byteField
&& charField    == lhs.charField
&& shortField   == lhs.shortField
&& intField     == lhs.intField
&& longField    == lhs.longField
&& floatField   == lhs.floatField
&& doubleField  == lhs.doubleField

// Arrays

&& Arrays.equals(arrayField, lhs.arrayField)

// Objects

&& referenceField.equals(lhs.referenceField)
&& (nullableReferenceField == null
? lhs.nullableReferenceField == null
: nullableReferenceField.equals(lhs.nullableReferenceField));
}
``````