Equals as well as hashcode methods are 2 primary but nonetheless 1 of nearly of import methods for coffee developers to hold out aware of. Java intends to supply equals as well as hashcode for every shape to evidence the equality as well as to supply a hash or digest based on content of class. Importance of hashcode increases when nosotros role the object inward dissimilar collection classes which works on hashing regulation e.g. hashtable as well as hashmap. Influenza A virus subtype H5N1 good written hashcode method tin improve functioning drastically yesteryear distributing objects uniformly as well as avoiding collision. In this article nosotros volition see how to correctly override hashcode() method inward coffee amongst a elementary example. We volition likewise examine of import facial expression of hashcode contracts inward java. This is inward continuation of my before postal service on overriding equals method inward Java, if y'all haven’t read already I would advise instruct through it.
General Contracts for hashCode() inward Java
1) If 2 objects are equal yesteryear equals() method therefore in that place hashcode returned yesteryear hashCode() method must hold out same.
2) Whenever hashCode() mehtod is invoked on the same object to a greater extent than than in 1 trial inside unmarried execution of application, hashCode() must render same integer provided no information or fields used inward equals as well as hashcode is modified. This integer is non required to hold out same during multiple execution of application though.
3) If 2 objects are non equals yesteryear equals() method it is non require that in that place hashcode must hold out different. Though it’s ever skillful practise to render dissimilar hashCode for unequal object. Different hashCode for distinct object tin improve functioning of hashmap or hashtable yesteryear reducing collision.
To ameliorate sympathize concept of equals as well as hashcode as well as what happens if y'all don’t override them properly I would recommend agreement of How HashMap works inward Java
Overriding hashCode method inward Java
We volition follow measurement yesteryear measurement approach for overriding hashCode method. This volition enable us to sympathize the concept as well as procedure better. 1) Take a prime number hash e.g. 5, 7, 17 or 31 (prime discover every bit hash, results inward distinct hashcode for distinct object)
2) Take roughly other prime number every bit multiplier dissimilar than hash is good.
3) Compute hashcode for each fellow member as well as add together them into terminal hash. Repeat this for all members which participated inward equals.
4) Return hash
Here is an illustration of hashCode() method
@Override
public int hashCode() {
int hash = 5;
hash = 89 hash + (this.name != zip ? this.name.hashCode() : 0);
hash = 89 hash + (int) (this.id ^ (this.id >>> 32));
hash = 89 hash + this.age;
render hash;
}
It’s ever skillful to check zip before calling hashCode() method on members or fields to avoid NullPointerException, if fellow member is zip than render zero. Different information types has dissimilar agency to compute hashCode.Integer members are simplest nosotros simply add together in that place value into hash, for other numeric data-type are converted into int as well as therefore added into hash. Joshua bloach has sum tables on this. I to a greater extent than ofttimes than non relied on IDE for this.
Better agency to override equals as well as hashCode
In my thought ameliorate agency to override both equals as well as hashcode method should hold out left to IDE. I accept seen Netbeans as well as Eclipse as well as works life that both has fantabulous back upward of generating code for equals as well as hashcode as well as in that place implementations seems to follow all best practise as well as requirement e.g. zip banking concern stand upward for , instanceof banking concern stand upward for etc as well as likewise frees y'all to hollo back how to compute hashcode for dissimilar data-types. Let’s come across how nosotros tin override hashcode method inward Netbeans as well as Eclipse.
In Netbeans
1) Write your Class.
2) Right click + insert code + Generate equals() as well as hashCode().
In Eclipse
1) Write your Class.
2) Go to Source Menu + Generate hashCode() as well as equals()
Things to hollo back spell overriding hashcode inward Java
1. Whenever y'all override equals method, hashcode should hold out overridden to hold out inward compliant of equals hashcode contract.
2. hashCode() is declared inward Object shape as well as return type of hashcode method is int as well as non long.
3. For immutable object y'all tin cache the hashcode in 1 trial generated for improved performance.
4. Test your hashcode method for equals hashcode compliance.
5. If y'all don't override hashCode() method properly your Object may non business office correctly on hash based collection e.g. HashMap, Hashtable or HashSet.
Complete illustration of equals as well as hashCode
public class Stock {
private String symbol;
private String exchange;
private long lotSize;
private int tickSize;
private boolean isRestricted;
private Date settlementDate;
private BigDecimal price;
@Override
public int hashCode() {
final int prime number = 31;
int outcome = 1;
outcome = prime number * result
+ ((exchange == null) ? 0 : exchange.hashCode());
outcome = prime number * outcome + (isRestricted ? 1231 : 1237);
outcome = prime number * outcome + (int) (lotSize ^ (lotSize >>> 32));
outcome = prime number * outcome + ((price == null) ? 0 : price.hashCode());
outcome = prime number * result
+ ((settlementDate == null) ? 0 : settlementDate.hashCode());
outcome = prime number * outcome + ((symbol == null) ? 0 : symbol.hashCode());
outcome = prime number * outcome + tickSize;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || this.getClass() != obj.getClass()){
return false;
}
Stock other = (Stock) obj;
return
this.tickSize == other.tickSize && this.lotSize == other.lotSize &&
this.isRestricted == other.isRestricted &&
(this.symbol == other.symbol|| (this.symbol != null && this.symbol.equals(other.symbol)))&&
(this.exchange == other.exchange|| (this.exchange != null && this.exchange.equals(other.exchange))) &&
(this.settlementDate == other.settlementDate|| (this.settlementDate != null && this.settlementDate.equals(other.settlementDate))) &&
(this.price == other.price|| (this.price != null && this.price.equals(other.price)));
}
}
Writing equals as well as hashcode using Apache Commons EqualsBuilder as well as HashCodeBuilder
EqualsBuilder as well as HashCodeBuilder from Apache common are much ameliorate agency to override equals as well as hashcode method, at to the lowest degree much ameliorate than ugly equals, hashcode generated yesteryear Eclipse. I accept written same illustration yesteryear using HashCodebuilder as well as EqualsBuilder as well as forthwith y'all tin come across how clear as well as concise they are.
@Override
populace boolean equals(Object obj){
if (obj instanceof Stock) {
Stock other = (Stock) obj;
EqualsBuilder builder = novel EqualsBuilder();
builder.append(this.symbol, other.symbol);
builder.append(this.exchange, other.exchange);
builder.append(this.lotSize, other.lotSize);
builder.append(this.tickSize, other.tickSize);
builder.append(this.isRestricted, other.isRestricted);
builder.append(this.settlementDate, other.settlementDate);
builder.append(this.price, other.price);
return builder.isEquals();
}
render false;
}
@Override
populace int hashCode(){
HashCodeBuilder builder = novel HashCodeBuilder();
builder.append(symbol);
builder.append(exchange);
builder.append(lotSize);
builder.append(tickSize);
builder.append(isRestricted);
builder.append(settlementDate);
builder.append(price);
render builder.toHashCode();
}
populace static void main(String args[]){
Stock sony = novel Stock("6758.T", "Tkyo Stock Exchange", 1000, 10, false, novel Date(), BigDecimal.valueOf(2200));
Stock sony2 = novel Stock("6758.T", "Tokyo Stock Exchange", 1000, 10, false, novel Date(), BigDecimal.valueOf(2200));
System.out.println("Equals result: " + sony.equals(sony2));
System.out.println("HashCode result: " + (sony.hashCode()== sony2.hashCode()));
}
Only thing to trouble concern is that it adds dependency on apache common jar, nearly people role it but if y'all are non using than y'all involve to include it for writing equals as well as hashcode method.
Further Learning
Complete Java Masterclass
How to role Generic inward Java Collection