Overriding Equals() Together With Hashcode() Method Inwards Coffee Together With Hibernate

Override equals in addition to hashCode inwards Java

Equals in addition to hashCode inwards Java are 2 primal methods which are declared inwards Object degree in addition to role or substance Java library. equals() method is used to compare Objects for equality piece hashCode is used to generate an integer code corresponding to that object. equals in addition to hashCode direct hold used extensively inwards Java substance library similar they are used piece inserting in addition to retrieving Object inwards HashMap, encounter how to acquire method of HashMap plant inwards Java for the sum story, equals method is too used to avoid duplicates on HashSet in addition to other Set implementation in addition to every other house where you lot demand to compare Objects. Default implementation of equals() degree provided yesteryear java.lang.Object compares retentiveness place in addition to solely render truthful if 2 reference variable is pointing to same retentiveness place i.e. essentially they are the same object. Java recommends to override equals in addition to hashCode method if equality is going to live defined yesteryear logical way or via or therefore describe concern logic in addition to many classes inwards Java measure library does override it e.g. String overrides equals,  whose implementation of equals() method render truthful if the content of 2 String objects is precisely same. Integer wrapper degree overrides equal to perform numerical comparing etc.

Since HashMap in addition to Hashtable inwards Java rely on equals() in addition to hashCode() method for comparing keys in addition to values, Java provides next rules to override equals method Java. As per next dominion equals method inwards Java should be:

1) Reflexive : Object must live equal to itself.

2) Symmetric : if a.equals(b) is truthful therefore b.equals(a) must live true.

3) Transitive : if a.equals(b) is truthful in addition to b.equals(c) is truthful therefore c.equals(a) must live true.

4) Consistent : multiple invocations of equals() method must render the same value until whatever of properties are modified. So if 2 objects are equals inwards Java they volition rest equals until whatever of their holding is modified.

5) Null comparing : comparing whatever object to aught must live simulated in addition to should non number inwards NullPointerException. For representative a.equals(null) must live false, passing unknown object, which could live null,  to equals inwards Java is is genuinely a Java coding best do to avoid NullPointerException inwards Java.

Equals in addition to hashCode contract inwards Java

And equals method inwards Java must follow its contract amongst hashcode method inwards Java equally stated below.

1) If 2 objects are equal yesteryear equals() method therefore at that spot hashcode must live same.

2) If 2 objects are non equal yesteryear equals() method therefore at that spot hashcode could live same or different.

So this was the basic theory well-nigh equals method inwards Java similar a shot nosotros are going to hash out the approach on how to override equals() method, yep I know you lot all know this materials :) but I direct hold seen or therefore of equals() code which tin live improved yesteryear next right approach. For illustration purpose nosotros volition encounter an representative of Person degree in addition to hash out How to write equals() method inwards Java for that class.

Steps to Override equals method inwards Java

Here is my approach for overriding equals method inwards Java. This is based on measure approach most of Java programmer follows piece writing equals method inwards Java.

1) Do this cheque -- if yep therefore render true.

2) Do null cheque -- if yep therefore render false.

3) Do the instanceof check,  if instanceof render false than render false from equals inwards Java , afterward or therefore inquiry I institute that instead of instanceof nosotros tin utilisation getClass() method for type identification because instanceof cheque returns truthful for subclass also, therefore its non strictly equals comparing until required yesteryear describe concern logic. But instanceof cheque is fine if your degree is immutable in addition to no ane is going to sub degree it. For representative nosotros tin supervene upon instanceof cheque yesteryear below code

if((obj == null) || (obj.getClass() != this.getClass())) {         return false; }

4) Type cast the object; Federal Reserve annotation the sequence instanceof cheque must live prior to casting object.

5) Compare private attribute starting amongst numeric attribute because comparing numeric attribute is fast in addition to utilisation brusk circuit operator for combining checks.  If kickoff champaign does non match, don't endeavour to tally residuum of attribute in addition to render false. It’s too worth to yell back doing aught cheque on private attribute earlier calling equals() method on them recursively to avoid NullPointerException during equals cheque inwards Java.

Code Example of overriding equals method inwards Java

5 tips to override hashcode inwards Java for detailed representative in addition to explanation of the right way to implement hashcode method.

/**   * Person degree amongst equals in addition to hashcode implementation inwards Java  * @author Javin Paul  */ public class Person {     private int id;     private String firstName;     private String lastName;      public int getId() { return id; }     public void setId(int id) { this.id = id;}      public String getFirstName() { return firstName; }     public void setFirstName(String firstName) { this.firstName = firstName; }      public String getLastName() { return lastName; }     public void setLastName(String lastName) { this.lastName = lastName; }      @Override     public boolean equals(Object obj) {         if (obj == this) {             return true;         }         if (obj == null || obj.getClass() != this.getClass()) {             return false;         }          Person invitee = (Person) obj;         return id == guest.id                 && (firstName == guest.firstName                       || (firstName != null && firstName.equals(guest.getFirstName())))                 && (lastName == guest.lastName                       || (lastName != null && lastName .equals(guest.getLastName())));     }          @Override     public int hashCode() {         final int prime number = 31;         int number = 1;         number = prime number * number                 + ((firstName == null) ? 0 : firstName.hashCode());         number = prime number * number + id;         number = prime number * number                 + ((lastName == null) ? 0 : lastName.hashCode());         return result;     }      }

If you lot hold off higher upwards method nosotros are kickoff checking for "this" cheque which is fastest available cheque for equals method therefore nosotros are verifying whether object is aught or non in addition to object is of same type or not. solely afterward verifying type of object nosotros are casting it into desired object to avoid whatever ClassCastException inwards Java. Also piece comparing private attribute nosotros are comparing numeric attribute kickoff using brusk circuit operator to avoid farther calculation if its already unequal in addition to doing aught cheque on fellow member attribute to avoid NullPointerException.

     

Common Errors piece overriding equals inwards Java

Though equals() in addition to hashcode() method are defined inwards Object degree along amongst wait, notify in addition to notifyAll,  and ane of primal role of Java programming I direct hold seen many programmers making fault piece writing equals() method inwards Java. I recommend all Java programmer who has merely started programming to write brace of equals in addition to hashcode method for at that spot domain or value object to acquire experience of it. Here I am listing or therefore of mutual mistakes I direct hold observed on diverse equals method inwards Java, if you lot similar to larn to a greater extent than well-nigh mutual mistakes inwards Java programming therefore encounter my postal service Don’t utilisation float in addition to double for monetary calculation in addition to Mixing static in addition to non static synchronized method. Now let’s encounter mutual mistakes yesteryear Java programmers piece overriding equals inwards Java :

1) Instead of overriding equals() method programmer overloaded it.

This is the most mutual error I direct hold seen piece overriding equals method inwards Java. Syntax of equals method defined inwards Object degree is public boolean equals(Object obj) but many people unintentionally overloads equals method inwards Java yesteryear writing public boolean equals(Person obj), instead of using Object equally declaration they utilisation at that spot degree name. This error is real difficult to observe because of static binding. So if you lot telephone band this method inwards your degree object it volition non solely compile but too execute correctly but if you lot endeavour to set your object inwards collection e.g. ArrayList in addition to telephone band contains() method which is based on equals() method inwards Java it volition non able to observe your object. So beware of it. This inquiry is too a oftentimes asked inquiry inwards Java interviews equally role of Overloading vs Overriding inwards Java equally how do you lot forestall this from happening ? Thankfully along-with Generics, Enum, autoboxing in addition to varargs Java v too introduces @Override annotation which tin live used to tell compiler that you lot are overriding a method in addition to than compiler volition live able to observe this error during compile time. Consistently using @Override annotation is too a best do inwards Java.

2) Second fault I direct hold seen piece overriding equals() method is non doing aught cheque for fellow member variables which ultimately results inwards NullPointerException in Java during equals() invocation. For representative inwards higher upwards code right way of calling equals() method of fellow member variable is afterward doing aught cheque equally shown below:

firstname == guest.firstname || (firstname != null && firstname.equals(guest.firstname)));

3) Third mutual fault is non overriding hashCode method inwards Java in addition to solely overriding equals() method. You must direct hold to override both equals() in addition to hashCode() method inwards Java , otherwise your value object volition non live able to utilisation equally key object inwards HashMap because working of HashMap is based on equals() in addition to hashCode to read to a greater extent than encounter , How HashMap plant inwards Java.

4) Last mutual fault programmer brand piece overriding equals() inwards Java is non keeping equals() in addition to compareTo() method consistent which is a non formal requirement inwards guild to obey contract of Set to avoid duplicates. SortedSet implementation similar TreeSet uses compareTo to compare 2 objects similar String in addition to if compareTo() in addition to equals() volition non live consistent than TreeSet volition allow duplicates which volition interruption Set contract of non having duplicates. To larn to a greater extent than well-nigh this number encounter my postal service Things to yell back piece overriding compareTo inwards Java

Writing JUnit tests for equals method inwards Java

Its skilful coding practice to write JUnit examine cases to examine your equals in addition to hashCode method. Here is my approach for writing JUnit examine representative for equals method inwards Java. I volition write examine cases to cheque equals behaviour, contract of equals in addition to hasCode method in addition to properties of equals method inwards Java on dissimilar circumstances. You tin too JUnit4 annotation to write JUnit test cases, than you lot don’t demand to utilisation examine prefix on examine method, merely utilisation @Test annotations.

testReflexive() this method volition examine reflexive nature of equals() method inwards Java.

testSymmeteric() this method volition verify symmetric nature of equals() inwards Java.

testNull() this method volition verify aught comparing in addition to volition locomote yesteryear if equals method returns false.

testConsistent() should verify consistent nature of equals method inwards Java.

testNotEquals() should verify if 2 object which are non supposed to equals is genuinely non equal, having negative examine cases inwards examine suite is mandatory.

testHashCode() volition verify that if 2 objects are equal yesteryear equals() method inwards Java therefore at that spot hashcode must live same. This is an of import examine if you lot are thinking to utilisation this object equally key inwards HashMap or Hashtable

5 Tips on writing equals method inwards Java

Here are or therefore tips to implement equals in addition to hashCode method inwards Java, this volition assistance you lot to do it correctly in addition to amongst ease:

1) Most of the IDE similar NetBeans, Eclipse in addition to IntelliJ IDEA provides back upwards to generate equals() in addition to hashcode() method. In Eclipse do the right click-> beginning -> generate hashCode() in addition to equals().

2) If your domain degree has whatever unique describe concern key therefore merely comparing that champaign inwards equals method would live plenty instead of comparing all the fields e.g. inwards representative of our representative if "id" is unique for every Person in addition to yesteryear merely comparing id nosotros tin position whether 2 Person are equal or not.

3) While overriding hashCode inwards Java makes certain you lot utilisation all fields which direct hold been used inwards equals method inwards Java.

4) String and Wrapper classes similar Integer, Float in addition to Double override equals method but StringBuffer doesn’t override it.

5) Whenever possible endeavour to brand your fields immutable yesteryear using final variables inwards Java, equals method based on immutable fields are much secure than on mutable fields.

6) Don't utilisation instanceof check inwards equals method, equally it could interruption contract of equals() method inwards sub-class, results inwards non-symmetric equals, because instanceof return truthful for kid degree equally well. For example, if you lot compare 2 objects Parent and Child from same type-hierarchy; Parent.equals(child) volition render true, because child instanceof Parent is true, but Child.equals(parent) volition render false, because Parent instanceof Child is false. This way equals() is non next symmetric contract, which states if a.equals(b) == true than b.equals(a) == true, equally shown below :

public class Parent { }  public class Child extends Parent { }  public class InstanceOfCheck {      public static void main(String args[]) {          Parent p = new Parent();         Child c = new Child();          System.out.println("child instanceof Parent " + (c instanceof Parent));         System.out.println("parent instanceof Child " + (p instanceof Child));      }  }  Output : child instanceof Parent true parent instanceof Child false

Alternatively, you lot tin grade equals equally terminal method to forestall it from beingness overridden.

7) While comparing String object inwards Java, prefer equals() than == operator.

8) Use IDE or Apache green EqualsBuilder and HashCodeBuilder utility classes to automatically implement equals() and hashcode() method inwards Java.

9) Two object which is logically equal but loaded from dissimilar ClassLoader cannot live equals. Remember that getClass() check, it volition render false if degree loader is different.

10) Use @Override annotation on hashcode() equally well, equally it too prevents subtle mistakes over render type. e.g. render type of hashcode() method is int, but many times programmers mistakenly set long.

11) One  example, where equals method is non consistent with compareTo is java.math.BigDecimal class. If you lot compare two BigDecimal object e.g. 120.00 and 120.000, equals method volition render false, while compareTo will render zero. Both are inconsistent, because equals accept both scale in addition to value inwards consideration, while compareTo method solely consider values. 

12) From Java seven you lot tin too utilisation a novel utility degree called java.util.Objects for aught rubber equality cheque in addition to calculating hash code. You tin supervene upon our null-safe code for cheque equality :

(name == guest.name || (name != null && name.equals(guest.getName()))) 

to much concise

Objects.equals(name, guest.getName());

Use of Equals in addition to Hashcode Method inwards Hibernate

Hibernate is a popular, opened upwards beginning Java persistent framework, which provides Object Relational Mapping, too known equally ORM framework. It uses equals and hashcode method to supply object's equality inwards Java side.  You should override equals() in addition to hashcode() if :

1) You are storing instance of persistent degree inwards a Set for representing many-valued associations.

2) You are using reattachment of detached persistent instances.

Another worth noting indicate is that Hibernate only guarantees equivalence of database row (persistent identity) in addition to Java object within a exceptional Session. Which way if you lot shop instances retrieved inwards dissimilar Sessions inwards a Set, you lot volition live having duplicates. Now the most of import human face of overriding equals in addition to hashcode() for hibernate entity classes, you lot should never create upwards one's heed equality merely based upon identifier. Though it’s convenient to compare identifier to encounter if the belong to same database row, Unfortunately, nosotros can't utilisation this approach amongst generated identifiers. Since Hibernate only assign identifier values to the object that are persistent, a newly created instance volition non direct hold whatever identifier value. Similarly, if an instance is non persisted, in addition to currently inwards a Set, saving it to database volition assigned an identifier value, which volition farther alter the value of hashcode() method, finally results inwards breaking the contract of the Set. That's why it's best to implement equals in addition to hashcode inwards Hibernate using describe concern key equality e.g. an Employee is same if it's name, surname, father's name, department, appointment of nativity is same. Properties which are non prone to alter e.g. appointment of nativity are meliorate candidate of describe concern equality than those which is easier to alter e.g. address in addition to contact number.

In short, yell back these best practices piece overriding equals() in addition to hashcode() for Hibernate entity degree :

1) Don't allow your equals() method solely uses identifier values for equivalence check.

2) Implement equals() in addition to hashCode() using existent give-and-take key that would position instance inwards existent world.

3) Use Immutable in addition to unique properties of objects for equality.


4) Don't utilisation getClass() to compare object equality because Hibernate uses proxy in addition to this cheque volition e'er fail. Instead utilisation instanceof operator, it observe proxy because they direct hold IS-A human relationship amongst actual object.


5) Use getter in addition to setter methods to access properties instead of straight accessing the, because hibernate lazily initialize object, when at that spot getProperty() method is called. Using mention may render aught but getName() may render value from database.

That’s all well-nigh overriding equals() in addition to hashcode() methods inwards Java, I am reiterating this but its imperative for a Java programmer to live able to write equals , hashcode(), compareTo() method yesteryear hand. It is non merely useful for learning purpose but to clear any coding exercise during Java interviews. Writing code for equals in addition to hashcode is real pop programming interview questions similar a shot days. For Hibernate persistent degree its rather tricky to override equals() and hashCode() because otherwise bad practices turns into best practices because of extensive of proxy. You should non utilisation Eclipse IDE code generator for equals() and hashCode() for hibernate entity class, equally they utilisation getClass() to cheque type equality.

Further Learning
Complete Java Masterclass
Java Fundamentals: The Java Language
Java In-Depth: Become a Complete Java Engineer!

Share this post