Effective Java with Groovy - Are you implementing equals and hashCode correctly?

Naresha K | | 2 min read

Consider the following Groovy code.

class Product {
    String sku
    String description
    BigDecimal price
}

Now let's put the Product class into use as follows.

Product book1 = new Product(sku: 'P101', description: 'Effective Java', price: 599.0)
Product book2 = new Product(sku: 'P101', description: 'Effective Java', price: 599.0)
println book1 == book2

We create two instances of Products using the same set of values. The above piece of code prints false. Since we didn't override equals, the method defined in java.lang.Object will be inherited by Product class. According to the implementation in java.lang.Object, two instances are equal only when both the references are pointing to the same object.

// Continues from the previous example
def stock = [:]
stock[book1] = 100
println stock[book2]

Here, I create a Map object ([:] creates an empty map) and store a value 100 with object book1 as the key. Then I used the second book object to lookup. Here we end up receiving null. The value returned from the hashCode() method is used in map operations. As per the implementation from java.lang.Object, every instance will have a unique hash code.

Now we understand that we should override equals() and hashCode() methods in Product class. While overriding them, we also need to ensure that whenever two instances are equal, they should also have the same hash code.

A sample implementation is as follows.

class Product {
    String sku
    String description
    BigDecimal price

    boolean equals(o) {
        if (this.is(o)) return true
        if (getClass() != o.class) return false

        Product product = (Product) o

        if (description != product.description) return false
        if (price != product.price) return false
        if (sku != product.sku) return false

        return true
    }

    int hashCode() {
        int result
        result = (sku != null ? sku.hashCode() : 0)
        result = 31 * result + (description != null ? description.hashCode() : 0)
        result = 31 * result + (price != null ? price.hashCode() : 0)
        return result
    }
}

Here I have used the template provided by my IDE, IntelliJ IDEA. One could also make use of utility classes provided by libraries such as "Apache Commons Lang" (It gives EqualsBuilder and HashCodeBuilder). I find two problems with the above approach.

The first one - to maintain the consistency between equals and hashCode, both of these methods have to rely upon the same set of attributes. Hence, we are violating the DRY(Don't Repeat Yourself) principle in the above code. Note how equals and hashCode are on their own in deciding what attributes they should consider.

Second - Often, our code keeps evolving, and we might be adding more fields to our Product class. While IDE code generation works for the first time, it doesn't help when we add another attribute. Developers might also forget to update these methods when they introduce new attributes.

If you are new to Groovy, you might want to get a taste of Groovy from this post.

Now let's explore how Groovy solve's the above two problems. Groovy provides an AST transformation groovy.transform.EqualsAndHashCode, which can be applied to the class as follows.

import groovy.transform.EqualsAndHashCode

@EqualsAndHashCode
class Product {
    String sku
    String description
    BigDecimal price
}

While compiling, Groovy will generate the implementations for both equals and hashCode using all the three defined attributes. You can customise if only specific fields need to be considered for implementing equals and hashCode. An example is as follows.

@EqualsAndHashCode(includes = "sku,description,price")

The attributes to be considered are defined in a single place. Hence we are adhering to the DRY principle. Also, if you add additional attributes, you will have to compile your code, and the equals and hashCode methods get regenerated during compile time . Thus both the above problems are addressed by Groovy.

If you are interested in learning more about how Effective Java applies to Groovy code, you may want to take a look at my GR8Conf EU presentation.

References:

Share:
Show Comments