1. Introducción
Comparar objetos es una característica esencial de los lenguajes de programación orientados a objetos.
En este tutorial, veremos algunas de las características del lenguaje Java que nos permiten comparar objetos. Además, veremos estas características en bibliotecas externas.
2. == y ! = Operadores
Comencemos con los operadores == y ! = Que pueden decir si dos objetos Java son iguales o no, respectivamente.
2.1. Primitivos
Para tipos primitivos, ser el mismo significa tener valores iguales:
assertThat(1 == 1).isTrue();Gracias al desempaquetado automático, esto también funciona cuando se compara un valor primitivo con su contraparte de tipo contenedor :
Integer a = new Integer(1); assertThat(1 == a).isTrue();Si dos enteros tienen valores diferentes, el operador == devolvería falso , mientras que el operador ! = Devolvería verdadero .
2.2. Objetos
Digamos que queremos comparar dos tipos de envoltorios Integer con el mismo valor:
Integer a = new Integer(1); Integer b = new Integer(1); assertThat(a == b).isFalse();Al comparar dos objetos, el valor de esos objetos no es 1. Más bien son sus direcciones de memoria en la pila las que son diferentes, ya que ambos objetos fueron creados usando el operador nuevo . Si hubiéramos asignado un a b , entonces nosotros hemos tenido un resultado diferente:
Integer a = new Integer(1); Integer b = a; assertThat(a == b).isTrue();Ahora, veamos qué sucede cuando usamos el método de fábrica Integer # valueOf :
Integer a = Integer.valueOf(1); Integer b = Integer.valueOf(1); assertThat(a == b).isTrue();En este caso, se consideran iguales. Esto se debe a que el método valueOf () almacena el Integer en una caché para evitar crear demasiados objetos de envoltura con el mismo valor. Por lo tanto, el método devuelve la misma instancia de Integer para ambas llamadas.
Java también hace esto para String :
assertThat("Hello!" == "Hello!").isTrue();Sin embargo, si se crearan con el operador nuevo , no serían iguales.
Finalmente, dos referencias nulas se consideran iguales, mientras que cualquier objeto no nulo se considerará diferente de nulo :
assertThat(null == null).isTrue(); assertThat("Hello!" == null).isFalse();Por supuesto, el comportamiento de los operadores de igualdad puede ser limitante. ¿Qué sucede si queremos comparar dos objetos asignados a direcciones diferentes y, sin embargo, considerarlos iguales en función de sus estados internos? Veremos cómo en las próximas secciones.
3. El número de objeto es igual al método
Ahora, hablemos de un concepto más amplio de igualdad con el método equals () .
Este método se define en la clase Object para que todos los objetos Java lo hereden. Por defecto, su implementación compara direcciones de memoria de objetos, por lo que funciona igual que el operador == . Sin embargo, podemos anular este método para definir qué significa la igualdad para nuestros objetos.
Primero, veamos cómo se comporta para objetos existentes como Integer :
Integer a = new Integer(1); Integer b = new Integer(1); assertThat(a.equals(b)).isTrue();El método aún devuelve verdadero cuando ambos objetos son iguales.
Debemos tener en cuenta que podemos pasar un objeto nulo como argumento del método, pero, por supuesto, no como el objeto al que llamamos el método.
Podemos usar el método equals () con un objeto propio. Digamos que tenemos una clase Person :
public class Person { private String firstName; private String lastName; public Person(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } }Podemos anular el método equals () para esta clase para que podamos comparar dos Person s en función de sus detalles internos:
@Override public boolean equals(Object o) if (this == o) return true; if (o == null Para obtener más información, consulte nuestro artículo sobre este tema.
4. El número de objetos es igual al método estático
Let's now 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 would be thrown.
The equals() method of the Objects helper class solves that problems. It takes two arguments and compares them, also handling null values.
Let's compare Person objects again with:
Person joe = new Person("Joe", "Portman"); Person joeAgain = new Person("Joe", "Portman"); Person natalie = new Person("Natalie", "Portman"); assertThat(Objects.equals(joe, joeAgain)).isTrue(); assertThat(Objects.equals(joe, natalie)).isFalse();As we said, the method handles null values. Therefore, if both arguments are null it will return true, and if only one of them is null, it will return false.
This can be really handy. Let's say we want to add an optional birth date to our Person class:
public Person(String firstName, String lastName, LocalDate birthDate) { this(firstName, lastName); this.birthDate = birthDate; }Then, we'd have to update our equals() method but with null handling. We could do this by adding this condition to our equals() method:
birthDate == null ? that.birthDate == null : birthDate.equals(that.birthDate);However, if we add 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 are equal, and positive otherwise.
Let's say, in our Person class, we want to compare Person objects by their last name:
public class Person implements Comparable { //... @Override public int compareTo(Person 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 that 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 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. It isn't possible with Comparable if we also want to keep our current implementation, but we could implement our own Comparators.
Let's create a PersonComparator that will compare them only by their first names:
Comparator compareByFirstNames = Comparator.comparing(Person::getFirstName);Let's now sort a List of people using that Comparator:
Person joe = new Person("Joe", "Portman"); Person allan = new Person("Allan", "Dale"); List people = new ArrayList(); people.add(joe); people.add(allan); people.sort(compareByFirstNames); assertThat(people).containsExactly(allan, joe);There are 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 are first comparing last names, then first names. Then, we compare birth dates but as they are nullable we must say how to handle that so we give a second argument telling they should be compared according to their natural order but with null values going last.
7. Apache Commons
Let's now take a look at the Apache Commons library. First of all, let's import the Maven dependency:
org.apache.commons commons-lang3 3.10 7.1. ObjectUtils#notEqual Method
First, let's talk about the ObjectUtils#notEqual method. It takes two Object arguments, to determine if they are 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 that 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 as greater. It offers an overloaded version that offers to invert that behavior and consider them lesser, taking a boolean argument.
8. Guava
Now, let's take a look at Guava. First of all, let's import the dependency:
com.google.guava guava 29.0-jre 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 of this method says that it should be considered as deprecated since Java 7 provides the Objects#equals method.
8.2. Comparison Methods
Now, 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
En este artículo, analizamos las diferentes formas de comparar objetos en Java. Examinamos la diferencia entre igualdad, igualdad y ordenamiento. También echamos un vistazo a las características correspondientes en las bibliotecas Apache Commons y Guava.
Como de costumbre, el código completo de este artículo se puede encontrar en GitHub.