1. Introduction
Comparing objects is an essential feature of object-oriented programming languages.
In this tutorial, we’ll explore some of the features of the Java language that allow us to compare objects. We’ll also look at such features in external libraries.
2. == and != Operators
Let’s begin with the == and != operators, which can tell if two Java objects are the same or not, respectively.
2.1. Primitives
For primitive types, being the same means having equal values:
assertThat(1 == 1).isTrue();
Thanks to auto-unboxing, this also works when comparing a primitive value with its wrapper type counterpart:
Integer a = new Integer(1);
assertThat(1 == a).isTrue();
If two integers have different values, the == operator will return false, while the != operator will return true.
2.2. Objects
Let’s say we want to compare two Integer wrapper types with the same value:
Integer a = new Integer(1);
Integer b = new Integer(1);
assertThat(a == b).isFalse();
By comparing two objects, the value of those objects isn’t 1. Rather, it’s their memory addresses in the stack that are different, since both objects are created using the new operator. If we assigned a to b, then we would have a different result:
Integer a = new Integer(1);
Integer b = a;
assertThat(a == b).isTrue();
Now let’s see what happens when we use the Integer#valueOf factory method:
Integer a = Integer.valueOf(1);
Integer b = Integer.valueOf(1);
assertThat(a == b).isTrue();
In this case, they’re considered the same. This is because the valueOf() method stores the Integer in a cache to avoid creating too many wrapper objects with the same value. Therefore, the method returns the same Integer instance for both calls.
Java also does this for String:
assertThat("Hello!" == "Hello!").isTrue();
However, if they’re created using the new operator, then they won’t be the same.
Finally, two null references are considered the same, while any non-null object is considered different from null:
assertThat(null == null).isTrue();
assertThat("Hello!" == null).isFalse();
Of course, the behavior of the equality operators can be limiting. What if we want to compare two objects mapped to different addresses and yet have them considered equal based on their internal states? We’ll see how to do this in the next sections.
3. Object#equals Method
Now let’s talk about a broader concept of equality with the equals() method.
This method is defined in the Object class so that every Java object inherits it. By default, its implementation compares object memory addresses, so it works the same as the == operator. However, we can override this method in order to define what equality means for our objects.
First, let’s see how it behaves for existing objects like Integer:
Integer a = new Integer(1);
Integer b = new Integer(1);
assertThat(a.equals(b)).isTrue();
The method still returns true when both objects are the same.
We should note that we can pass a null object as the argument of the method, but not as the object we call the method upon.
We can also use the equals() method with an object of our own. Let’s say we have a Person class:
public class PersonWithEquals {
private String firstName;
private String lastName;
public PersonWithEquals(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}
We can override the equals() method for this class so that we can compare two Persons based on their internal details:
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
PersonWithEquals that = (PersonWithEquals) o;
return firstName.equals(that.firstName) &&
lastName.equals(that.lastName);
}
For more information, check out our article about this topic.
4. Objects#equals Static Method
Now let’s look at the Objects#equals static method. We mentioned earlier that we can’t use null as the value of the first object, otherwise a NullPointerException will be thrown.
The equals() method of the Objects helper class solves that problem. It takes two arguments and compares them, also handling null values.
Let’s compare Person objects again:
PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
PersonWithEquals joeAgain = new PersonWithEquals("Joe", "Portman");
PersonWithEquals natalie = new PersonWithEquals("Natalie", "Portman");
assertThat(Objects.equals(joe, joeAgain)).isTrue();
assertThat(Objects.equals(joe, natalie)).isFalse();
As we explained, this method handles null values. Therefore, if both arguments are null, it’ll return true, and if only one of them is null, it’ll return false.
This can be really handy. Let’s say we want to add an optional birth date to our Person class:
public PersonWithEquals(String firstName, String lastName, LocalDate birthDate) {
this(firstName, lastName);
this.birthDate = birthDate;
}
Then we have to update our equals() method, but with null handling. We can do this by adding the condition to our equals() method:
birthDate == null ? that.birthDate == null : birthDate.equals(that.birthDate);
However, if we add too many nullable fields to our class, it can become really messy. Using the Objects#equals method in our equals() implementation is much cleaner, and improves readability:
Objects.equals(birthDate, that.birthDate);
5. Comparable Interface
Comparison logic can also be used to place objects in a specific order. The Comparable interface allows us to define an ordering between objects by determining if an object is greater, equal, or lesser than another.
The Comparable interface is generic and has only one method, compareTo(), which takes an argument of the generic type and returns an int. The returned value is negative if this is lower than the argument, 0 if they’re equal, and positive otherwise.
Let’s say, in our Person class, we want to compare Person objects by their last name:
public class PersonWithEqualsAndComparable implements Comparable<PersonWithEqualsAndComparable> {
//...
@Override
public int compareTo(PersonWithEqualsAndComparable o) {
return this.lastName.compareTo(o.lastName);
}
}
The compareTo() method will return a negative int if called with a Person having a greater last name than this, zero if the same last name, and positive otherwise.
For more information, take a look at our article about this topic.
6. Comparator Interface
The Comparator interface is generic and has a compare method that takes two arguments of that generic type and returns an integer. We already saw this pattern earlier with the Comparable interface.
Comparator is similar; however, it’s separated from the definition of the class. Therefore, we can define as many Comparators as we want for a class, where we can only provide one Comparable implementation.
Let’s imagine we have a web page displaying people in a table view, and we want to offer the user the possibility to sort them by first names rather than last names. This isn’t possible with Comparable if we also want to keep our current implementation, but we can implement our own Comparators.
Let’s create a Person Comparator that will compare them only by their first names:
Comparator<Person> compareByFirstNames = Comparator.comparing(Person::getFirstName);
Now let’s sort a List of people using that Comparator:
Person joe = new Person("Joe", "Portman");
Person allan = new Person("Allan", "Dale");
List<Person> people = new ArrayList<>();
people.add(joe);
people.add(allan);
people.sort(compareByFirstNames);
assertThat(people).containsExactly(allan, joe);
There are also other methods on the Comparator interface we can use in our compareTo() implementation:
@Override
public int compareTo(Person o) {
return Comparator.comparing(Person::getLastName)
.thenComparing(Person::getFirstName)
.thenComparing(Person::getBirthDate, Comparator.nullsLast(Comparator.naturalOrder()))
.compare(this, o);
}
In this case, we’re first comparing last names, then first names. Next we compare birth dates, but as they’re nullable, we must say how to handle that. To do this, we give a second argument to say that they should be compared according to their natural order, with null values going last.
7. Apache Commons
Let’s take a look at the Apache Commons library. First of all, let’s import the Maven dependency:
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>
7.1. ObjectUtils#notEqual Method
First, let’s talk about the ObjectUtils#notEqual method. It takes two Object arguments to determine if they’re not equal, according to their own equals() method implementation. It also handles null values.
Let’s reuse our String examples:
String a = new String("Hello!");
String b = new String("Hello World!");
assertThat(ObjectUtils.notEqual(a, b)).isTrue();
It should be noted that ObjectUtils has an equals() method. However, that’s deprecated since Java 7, when Objects#equals appeared
7.2. ObjectUtils#compare Method
Now let’s compare object order with the ObjectUtils#compare method. It’s a generic method that takes two Comparable arguments of that generic type and returns an Integer.
Let’s see it using Strings again:
String first = new String("Hello!");
String second = new String("How are you?");
assertThat(ObjectUtils.compare(first, second)).isNegative();
By default, the method handles null values by considering them greater. It also offers an overloaded version that offers to invert that behavior and consider them lesser, taking a boolean argument.
8. Guava
Let’s take a look at Guava. First of all, let’s import the dependency:
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>31.0.1-jre</version>
</dependency>
8.1. Objects#equal Method
Similar to the Apache Commons library, Google provides us with a method to determine if two objects are equal, Objects#equal. Though they have different implementations, they return the same results:
String a = new String("Hello!");
String b = new String("Hello!");
assertThat(Objects.equal(a, b)).isTrue();
Though it’s not marked as deprecated, the JavaDoc for this method says that it should be considered as deprecated, since Java 7 provides the Objects#equals method.
8.2. Comparison Methods
The Guava library doesn’t offer a method to compare two objects (we’ll see in the next section what we can do to achieve that though), but it does provide us with methods to compare primitive values. Let’s take the Ints helper class and see how its compare() method works:
assertThat(Ints.compare(1, 2)).isNegative();
As usual, it returns an integer that may be negative, zero, or positive if the first argument is lesser, equal, or greater than the second, respectively. Similar methods exist for all the primitive types, except for bytes.
8.3. ComparisonChain Class
Finally, the Guava library offers the ComparisonChain class that allows us to compare two objects through a chain of comparisons. We can easily compare two Person objects by the first and last names:
Person natalie = new Person("Natalie", "Portman");
Person joe = new Person("Joe", "Portman");
int comparisonResult = ComparisonChain.start()
.compare(natalie.getLastName(), joe.getLastName())
.compare(natalie.getFirstName(), joe.getFirstName())
.result();
assertThat(comparisonResult).isPositive();
The underlying comparison is achieved using the compareTo() method, so the arguments passed to the compare() methods must either be primitives or Comparables.
9. Conclusion
In this article, we learned different ways to compare objects in Java. We examined the difference between sameness, equality, and ordering. We also looked at the corresponding features in the Apache Commons and Guava libraries.
As usual, the full code for this article can be found over on GitHub.