Compare Properties Of Two Objects

Question

I've two objects and need to compare their properties. The code currently use a very long sequence of if/else statements to step through the properties.

Is there a more intelligent to go about it?

For example, it looks like:

 if (car.getIsElectric() && (!parkingGarage.getIsElectric())) {
   log("Electric cars are not permitted here");
   return 1;
 }

 if (car.getIsSuv() && (!parkingGarage.getIsSuv())) {
   log("SUVs are not allowed in.");
   return 1;
 }
 ...

This questions is similar to: Comparing the properties of two objects and I want to see if there is an equivalent form in Java.

Answer 1

You can reflectively iterate over every field in the objects. My example assumes that the two objects are of the same exact type, but I'm sure that you can improve it to compare two different objects along the same class hierarchy.

public class Vehicle {

    public int width, height;

    public Vehicle(int int1, int int2) {
        this.width = int1;
        this.height = int2;
    }

    public static void main(String[] args) {
        Vehicle vehicle1 = new Vehicle(5, 10), vehicle2 = new Vehicle(5, 10), vehicle3 = new Vehicle(5, 20);

        System.out.println(equal(vehicle1, vehicle2));
        System.out.println(equal(vehicle2, vehicle3));
        System.out.println(equal(vehicle1, vehicle3));
    }

    public static boolean equal(Vehicle first, Vehicle other) {
        for (Field f : Vehicle.class.getDeclaredFields()) {
            try {
                if (!f.get(first).equals(f.get(other)))
                    return false;
            } catch (IllegalArgumentException e) {
                // Method callers can only pass in Test objects to this method, so this
                // shouldn't be thrown either. Watch out for callers passing in null to this
                // method though.
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // Fields are public and this method belongs to Test, so this shouldn't be
                // thrown.
                e.printStackTrace();
            }
        }
        return true;
    }

}

The main part of the above code is the static equal method. It compares each Field, declared in Vehicle, on each object and returns false if one is not equal. If you'd also like to compare fields inherited by Vehicle you can use getFields() instead of getDeclaredFields().

In short, the kind of code that I think you'd be looking for, is this:

for (Field f : Vehicle.class.getDeclaredFields())
    try {
        if (!f.get(first).equals(f.get(other)))
            return false;
    } catch (IllegalArgumentException | IllegalAccessException e) {
        e.printStackTrace();
    }
return true;

(Btw, I liked "an infinite sequence" better :) )

Answer 2

Note: This answer was for original question, comparing two objects of same type, and doesn't apply to updated question that checks access rules.

---

To compare two objects with a lot of if statements, we'll use a Vehicle object with 3 fields as an example:

class Vehicle {
    private final String  type;
    private final int     wheelCount;
    private final boolean electric;
}

As you already know, you have to write setters (or constructor) and getters for each one, so you already have "repetitive work" to do, so just get comfy with it:

    public Vehicle(String type, int wheelCount, boolean electric) {
        this.type = type;
        this.wheelCount = wheelCount;
        this.electric = electric;
    }
    public String getType() {
        return this.type;
    }
    public int getWheelCount() {
        return this.wheelCount;
    }
    public boolean isElectric() {
        return this.electric;
    }

And the standard methods:

    @Override
    public int hashCode() {
        int hash = this.type.hashCode();
        hash = hash * 31 + this.wheelCount;
        hash = hash * 3 + (this.electric ? 1 : 2);
        return hash;
    }
    @Override
    public boolean equals(Object obj) {
        if (! (obj instanceof Vehicle))
            return false;
        Vehicle that = (Vehicle) obj;
        return (this.type.equals(that.type)
             && this.wheelCount == that.wheelCount
             && this.electric == that.electric);
    }

So now you can simple do:

if (! car.equals(bus)) {
    return 1;
}

And that's the one and only if statement.

Answer 3

The first thing you need to do is for your class to implement the Comparable Interface. If your class creates composite objects (objects containing other objects), each one of these objects must implement the comparable interface as well. The second thing you need to do is to override Object.equals(Object) and Object.hashCode() methods. Your example is creating a static equals method which I strongly recommend you don't do. Like I mentioned before for implementing Comparable, the classes for all object references must override equals and hashCode.

The comparable interface has a single method: compareTo(T t). The purpose of this method is to compare two objects in order to determine if the two objects are SIMILAR (but not the same). For example, you can say two vehicles are similar if they are the same make/model, manufactured the same year, have the same options, engine, wheels, etc., but they have different VIN numbers. Basically, the two vehicles LOOK the same, but are not the exact same car. Meanwhile, the purpose of the equals and hashCode method is to establish object instance equality.

Following the same example, lets say you call the police because your vehicle is stolen. The police gather all the information about your car and they will investigate all cars that matches the description of the vehicle (looks like your car). But, upon looking up the VIN number, they determine that the car IS NOT your car. So basically....

yourVehicle.compareTo(suspiciousVechile); // return true
yourVehicle.equals(suspiciousVehicle); // returns false

Although this is not recommended in the Comparable interface Javadoc, you can have cases where a true result from compareTo can yield a different result than equals. This is for cases where an object is a copy of another, but they are different instances. Sometimes this fact is important; although often it is not.

I would suggest you look into Java's String class to see how they make use of both (compareTo and equals) methods. Ignore the fact that equals doesn't call compareTo internally.

Answer 4

For two arbitrary objects, you can reflectively iterate over the fields in one of the objects to see which fields the objects both have, 1:1. You can then compare these fields.

For the quick solution, check below.

Here's a really big and possibly annoying example:

class Test {

    public static Field getFieldSafely(String fieldName, Object object) {
        Field[] fields = object.getClass().getFields();
        for (Field f : fields)
            if (f.getName().equals(fieldName))
                return f;
        return null;
    }

    public static boolean equal(Object first, Object other) {
        for (Field f : first.getClass().getFields()) {
            String fieldName = f.getName();
            Field otherField = getFieldSafely(fieldName, other);
            if (otherField != null)
                try {
                    if (!f.get(first).equals(otherField.get(other)))
                        return false;
                } catch (IllegalArgumentException | IllegalAccessException e) {
                    e.printStackTrace();
                }
        }
        return true;
    }

    public static void main(String[] args) {
        Vehicle vehicle1 = new Vehicle(5, 10), vehicle2 = new Vehicle(5, 10), vehicle3 = new Vehicle(5, 20);
        Box box1 = new Box(5, 10), box2 = new Box(100, 200);

        System.out.println(equal(vehicle1, vehicle2));// True
        System.out.println(equal(vehicle2, vehicle3));// False
        System.out.println(equal(vehicle1, vehicle3));// False
        System.out.println(equal(box1, box2));// False
        System.out.println(equal(vehicle1, box1));// True
    }

}

class Box {
    public int width, height;

    public Box(int width, int height) {
        this.width = width;
        this.height = height;
    }

}

class Vehicle {

    public int width, height, weight;

    public Vehicle(int int1, int int2) {
        this.width = int1;
        this.height = int2;
    }

}

The most important methods are in the class Test. The method, equal(...), takes in two objects. It then checks if each field in the first object is contained in the second object. For each field it finds in the first object, that has the same name as a field in the second object, the fields are checked for equality. If all the fields found in both objects are equal, the method returns true. Otherwise, it returns false.

Here are the important methods. You can modify them as you see fit to meet your needs.

getFieldSafely(...) simply returns null if a field with the given name isn't found in the given object. Otherwise, it returns the field.

public static Field getFieldSafely(String fieldName, Object object) {
    Field[] fields = object.getClass().getFields();
    for (Field f : fields)
        if (f.getName().equals(fieldName))
            return f;
    return null;
}

public static boolean equal(Object first, Object other) {
    for (Field f : first.getClass().getFields()) {
        String fieldName = f.getName();
        Field otherField = getFieldSafely(fieldName, other);
        if (otherField != null)
            try {
                if (!f.get(first).equals(otherField.get(other)))
                    return false;
            } catch (IllegalArgumentException | IllegalAccessException e) {
                e.printStackTrace();
            }
    }
    return true;
}

Good luck. :)