Check if two objects are completely equal in Java

Question

I've got a Java class, here's an example:

public class Car {

    private int fuelType;
    private Date made;
    private String name;
.
.
. // and so on

Now let's say I have two car objects and I want to compare if all their variables are equal.

Right now, I've solved this by overriding method equals(Object o) and I check if all the variables match in both objects.

The problem here is that if I have 20 classes, I'll have to override equals(Object o) in every single one of them.

Is there a way create some sort of universal method that could compare any of the two objects that I pass to it and let me know if they match in every single variable or not?

Answer 1

You have a few options for automating Equals & Hashcode (option #3 BLEW MY MIND!):

1. Your IDE. I would not recommend it for most objects as they can slowly drift out of date with the actual class definition. They also look ugly and pollute your codebase with boilerplate code.
2. Apache Commons has a bunch of stuff for making this easier, including a reflective version so no risk of drifting out of date with the class definition. It is better than #1 unless you require a speedy equals/hashcode, but still too much boilerplate for my liking.
3. Project Lombok and annotation processing. Whack an EqualsAndHashCode annotation on ya class and be done with it. I recommend using Project Lombok. It adds a touch of magic into the build (but not much) and so requires a plugin for your IDE to behave nicely but they are a small price to pay for no boilerplate code. Lombok is an annotation processor that run at compile time so you have no runtime performance hit.
4. Using a different language that supports it out the box, but also targets the JVM. Groovy uses an annotation and Kotlin supports data classes. Unless your existing code can quickly be converted, I would avoid this.
5. Google's Auto has an AutoValue. Like Project Lombok this is an annotation processor, however has less magic at the expense of little more boilerplate (thanks to Louis Wasserman)

Answer 2

you can use :

 org.apache.commons.lang.builder.CompareToBuilder.reflectionCompare(Object lhs, Object rhs);

it uses reflection to compare the fileds here is the javadoc : javadoc

Answer 3

I'll take the dissenting opinion to the majority (use apache commons with reflection) here: Yes, this is a bit code you have to write (let your IDE generate really), but you only have to do it once and the number of data classes that need to implement equals/hashcode is generally rather manageable - at least in all of the large projects (250k+ LOC) I worked on.

Sure if you add a new member to the class you will have to remember to update the equals/hashcode functions, but that's generally easy to notice, at the latest during code reviews.

And honestly if you use a simple little helper class that's even in Java7, you can cut down the code that Wana Ant showed immensely. Really all you need is:

@Override
public boolean equals(Object o) {
    if (o instanceof Car) { // nb: broken if car is not final - other topic
        Car other = (Car) o;
        return Objects.equals(fuelType, other.fuelType) && 
               Objects.equals(made, other.made) && 
               Objects.equals(name, other.name);
    }
    return false;
}

similar for hashcode:

@Override
public int hashCode() {
    return Objects.hash(fuelType, made, name);
}

Not as short as the reflection solution? True, but it's simple, easy to maintain, adapt and read - and performance is orders of magnitude better (which for classes that implement equals and hashcode is often important)

Answer 4

Typically you can generate equals/hashCode methods by your IDE - all big players in this field are capable of that (Eclipse, IntelliJ Idea and Netbeans).

Generally you can create some code that will use reflection but I don't recommend this one as objective approach is clearer and more maintainable. Also reflection won't be as fast as "standard" way. If you really want to go this way, there exist utilities like EqualsBuilder and HashCodeBuilder.

Just for your information, there are JVM-based languages that already support these features, e.g. Kotlin data classes, which can be pretty nicely used in existing Java projects.

Answer 5

I'll just throw in a plug for my favorite solution to this problem: @AutoValue.

This is an open-source project from Google that provides an annotation processor that generates a synthetic class that implements equals and hashCode for you.

Since it's auto-generated code, you don't have to worry about accidentally forgetting a field or messing up the equals or hashCode implementation. But since the code is generated at compile time, there's zero runtime overhead (unlike reflection-based solutions). It's also "API-invisible" -- users of your class can't tell the difference between an @AutoValue type and a type you implemented yourself, and you can change back and forth in the future without breaking callers.

See also this presentation which explains the rationale and does a better job comparing it to other approaches.

Answer 6

Theoretically you could use reflection to create some kind of util, as many people suggest you in comments. Personally I don't recommend you to do it. you will end up with something which is partially working.

Many things in Java rely on equal or hashCode, for example method contains which you can find in anything which implements Collection.

Overriding equal (and hashCode) is recommended solution. By addition, i think any decent IDE will have option to generate them for you. Hence you can do it quicker than by using reflection.

Answer 7

That's the way I would do it:

@Override
public boolean equals(Object obj) {
    if (obj instanceof Car) {
        return internalEquals((Car) obj);
    }
    return super.equals(obj);
}

protected boolean internalEquals(Car other) {
    if(this==other){
        return true;
    }
    if (other != null) {
        //suppose fuelType can be Integer.
        if (this.getFuelType() !=null) {
            if (other.getFuelType() == null) {
                return false;
            } else if (!this.getFuelType().equals(other.getFuelType())) {
                return false;
            }
        } else if(other.getFuelType()!=null){
            return false;
        }
        if (this.getName() != null) {
            if (other.getName() == null) {
                return false;
            } else if (!this.getName().equals(other.getName())) {
                return false;
            }
        }
        else if(other.getName()!=null){
            return false;
        }
         if (this.getDate() != null) {
            if (other.getDate() == null) {
                return false;
            } else if (!this.getDate().getTime()!=(other.getDate().getTime())) {
                return false;
            }
        }
        else if(other.getDate()!=null){
            return false;
        }
        return true;
    } else {
        return false;
    }
}

EDIT
Simplified version

     public class Utils{
          /**
           * Compares the two given objects and returns true, 
           * if they are equal and false, if they are not.
           * @param a one of the two objects to compare
           * @param b the other one of the two objects to compare
           * @return if the two given lists are equal.
           */
           public static boolean areObjectsEqual(Object a, Object b) {

               if (a == b){
                  return true;
               }
               return (a!=null && a.equals(b));
          }

          public static boolean areDatesEqual(Date a, Date b){
             if(a == b){
                return true;
             }
             if(a==null || b==null){ 
                return false;
             }
             return a.getTime() == b.getTime();
          }
   }

   @Override
   public boolean equals(other obj) {
      if(this == other){
         return true;
      } 
      if(other == null){
          return false;
      }
      if (other instanceof Car) {
          return internalEquals((Car) other);
      }
      return super.equals(obj);
   }

   protected boolean internalEquals(Car other) {        
        //suppose fuelType can be Integer.
        if (!Utils.areObjectsEqual(this.getName(), other.getName()){                   
            return false;
        }
        if (!Utils.areObjectsEqual(this.getName(), other.getName()){ 
            return false;
        }
        if (!Utils.areDatesEqual(this.getDate(), other.getDate()){ 
            return false;
        } 
        return true;
    }
}

Also don't forget about hashcode, they code hand in hand.