Home > Java APIs, Java Know Hows > Apache Commons EqualsBuilder and HashCodeBuilder

Apache Commons EqualsBuilder and HashCodeBuilder

Introduction

Before we go ahead and explore Apache Commons EqualsBuilder and HashCodeBuilder we must know the relationship between equals and hashCode.
java.lang.Object which is the super class of all Java classes has two very important methods defined in it. They are –

  • public boolean equals(Object obj)
  • public int hashCode()

These two methods are very important when our classes deal with other Java classes such as Collection API used for searching, sorting, comparison and eliminate duplicate objects from a set.

public boolean equals(Object obj)

This method checks if some other object passed to it as an argument is equal to the object on which this method is invoked. The default implementation of this method in Object class simply checks if two object references x and y refer to the same object. i.e. It checks if x == y. This particular comparison is also known as “shallow comparison”. However, the classes providing their own implementations of the equals method are supposed to perform a “deep comparison”.

public int hashCode()

This method returns the hash code value for the object on which this method is invoked. This method returns the hash code value as an integer and is supported for the benefit of hashing based collection classes such as Hashtable, HashMap, HashSet etc.

Relationship between equals and hashCode

Equal objects must produce the same hash code as long as they are equal, however unequal objects need not produce distinct hash codes.

Implementation

While hashCode() and equals() typically impact logic and performance, they are also often more tricky to implement correctly. The most important rule is that when one of these two methods is overridden, the other one should be as well. Because it can be tricky to implement hashCode() and equals() correctly, it is helpful to have EqualsBuilder and HashCodeBuilder two reusable implementations of these provided as part of Apache Commons Lang builder package.
I particularly like the way how EqualsBuilder uses reflection to determine if the two Objects are equal or HashCodeBuilder uses reflection to build a valid hash code. But reflection hits the performance of application, so use it where the performance is not very critical. However these two builders also provide the alternative approach. Let’s demonstrate both approach one by one:

    • Using Reflection:
      Let’s create a simple class called Employee as following mentioned code –

      package blog.commons;
      
      import org.apache.commons.lang.builder.EqualsBuilder;
      import org.apache.commons.lang.builder.HashCodeBuilder;
      
      public class Employee {
      
      	private int id;
      	private String name;
      	private int deptId;
      	private String designation;
      
      	public Employee(int id, String name, int deptId, String designation) {
      		this.id = id;
      		this.name = name;
      		this.deptId = deptId;
      		this.designation = designation;
      	}
      
      	@Override
      	public boolean equals(Object obj) {
      		return EqualsBuilder.reflectionEquals(this, obj);
      	}
      
      	@Override
      	public int hashCode() {
      		return HashCodeBuilder.reflectionHashCode(this);
      	}
      }
      

      Now create a Main class the to check how it works –

      package blog.commons;
      
      import java.util.Arrays;
      import java.util.HashSet;
      import java.util.Set;
      
      public class Main {
      
      	public static void main(String[] args) {
      		Employee emp1 = new Employee(1, "Allen", 12, "Accountant");
      		Employee emp2 = new Employee(1, "Allen", 13, "Accountant");
      		System.out.println("Is emp1 equals to emp2: " + emp1.equals(emp2));
      		Set<Employee> employees = new HashSet<Employee>();
      		employees.addAll(Arrays.asList(emp1,emp2));
      
      		System.out.println("Size of set: " + employees.size());
      
      	}
      }
      

      If you execute the main method the output will be ass follows –

      Is emp1 equals to emp2: false
      Size of set: 2


      Here you can see that the employee “Allen” whose employee Id is “1” is an “Accountant” does his book keeping job for two different departments which department ids are 12 and 13 respectively. But the object emp1 and emp2 are treated as two different persons.
      Now, let’s exclude the deptId field to determine equality and building hashCode and see the effect. For doing the you need to slightly modify the code of Employee class –

      package blog.commons;
      
      import org.apache.commons.lang.builder.EqualsBuilder;
      import org.apache.commons.lang.builder.HashCodeBuilder;
      
      public class Employee {
      
      	private int id;
      	private String name;
      	private int deptId;
      	private String designation;
      
      	public Employee(int id, String name, int deptId, String designation) {
      		this.id = id;
      		this.name = name;
      		this.deptId = deptId;
      		this.designation = designation;
      	}
      
      	@Override
      	public boolean equals(Object obj) {
      		return EqualsBuilder.reflectionEquals(this, obj,new String[] {"deptId"});
      	}
      
      	@Override
      	public int hashCode() {
      		return HashCodeBuilder.reflectionHashCode(this,new String[] {"deptId"});
      	}
      }
      

      Again execute the same main method to see the output –

      Is emp1 equals to emp2: true
      Size of set: 1


      Here as you can see now emp1 and emp2 are treated as equal but emp1 are been replaced by emp2, hence the size of the set employees is one. To overcome this problem do not exclude the deptId while generating hashCode. Your hashCode method should look like the following –

      @Override
      	public int hashCode() {
      		return HashCodeBuilder.reflectionHashCode(this);
      	}
      

      Now the output should be shown as below if you execute the main method again-

      Is emp1 equals to emp2: true
      Size of set: 2

    • Without Using Reflection:

In my previous examples you have seen how easily and fascinating we can use reflection capability of EqualsBuilder and HashCodeBuilder to override equals and hashCode methods. Now, I am going to show you how can you achieve the same output without using reflection which helps to improve performance –

package blog.commons;

import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;

public class Employee {

	private int id;
	private String name;
	private int deptId;
	private String designation;

	public Employee(int id, String name, int deptId, String designation) {
		this.id = id;
		this.name = name;
		this.deptId = deptId;
		this.designation = designation;
	}

	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Employee == false) {
			return false;
		}

		if (this == obj) {
			return true;
		}
		Employee other = (Employee) obj;
		return new EqualsBuilder().append(this.id , other.id)
		.append(this.name , other.name)
		.append(this.deptId, other.deptId)
		.append(this.designation , other.designation).isEquals();
	}

	@Override
	public int hashCode() {
		return new HashCodeBuilder().append(this.id)
		.append(this.name)
		.append(this.deptId)
		.append(this.designation)
		.hashCode();
	}
}

If you run the main method this time you get similar output as it has been shown in last output result. Just notice here I am not appending deptId in EqualsBuilder but I am doing in while generating hashCode.

Like these EqualsBuilder and HashCodeBuilder Apache Commons project provides many such reusable APIs to speed up your application development time. You can find more information regarding Apache Commons from the following link http://commons.apache.org/.

Advertisements
Categories: Java APIs, Java Know Hows
  1. digitaljoel
    February 8, 2011 at 6:46 pm

    You have in bold in your article the fact that “Equal objects must produce the same hash code as long as they are equal, however unequal objects need not produce distinct hash codes.” and yet in your proposed implementation you break that very rule by including the dept id in hashcode and excluding it from equals. Now emp1.equals(emp2) is true, but emp1.hashcode() != emp2.hashcode().

    Now let’s say that I add emp1 to my list, but not emp2. If emp1.equals(emp2) then I would expect list.contains(emp2) to return true, but with your implementation it will not. But, thanks for the information on EqualsBuiler and HashCodeBuilder

  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: