Confronto di oggetti in Java

1. Introduzione

Il confronto di oggetti è una caratteristica essenziale dei linguaggi di programmazione orientati agli oggetti.

In questo tutorial, esamineremo alcune delle funzionalità del linguaggio Java che ci consentono di confrontare gli oggetti. Inoltre, esamineremo tali funzionalità nelle librerie esterne.

2. == e ! = Operatori

Cominciamo con gli operatori == e ! = Che possono dire se due oggetti Java sono uguali o meno, rispettivamente.

2.1. Primitivi

Per i tipi primitivi, essere lo stesso significa avere valori uguali:

assertThat(1 == 1).isTrue();

Grazie all'unboxing automatico, funziona anche quando si confronta un valore primitivo con la sua controparte di tipo wrapper :

Integer a = new Integer(1); assertThat(1 == a).isTrue();

Se due numeri interi hanno valori diversi, l' operatore == restituirà false , mentre l' operatore ! = Restituirà true .

2.2. Oggetti

Supponiamo di voler confrontare due tipi di wrapper Integer con lo stesso valore:

Integer a = new Integer(1); Integer b = new Integer(1); assertThat(a == b).isFalse();

Confrontando due oggetti, il valore di quegli oggetti non è 1. Piuttosto sono i loro indirizzi di memoria nello stack che sono diversi poiché entrambi gli oggetti sono stati creati utilizzando l' operatore new . Se avessimo assegnato a a b , avremmo ottenuto un risultato diverso:

Integer a = new Integer(1); Integer b = a; assertThat(a == b).isTrue();

Ora, vediamo cosa succede quando usiamo il metodo Integer # valueOf factory:

Integer a = Integer.valueOf(1); Integer b = Integer.valueOf(1); assertThat(a == b).isTrue();

In questo caso, sono considerati uguali. Questo perché il metodo valueOf () memorizza l' Integer in una cache per evitare di creare troppi oggetti wrapper con lo stesso valore. Pertanto, il metodo restituisce la stessa istanza Integer per entrambe le chiamate.

Java lo fa anche per String :

assertThat("Hello!" == "Hello!").isTrue();

Tuttavia, se fossero stati creati utilizzando il nuovo operatore, non sarebbero gli stessi.

Infine, due riferimenti nulli sono considerati uguali, mentre qualsiasi oggetto non nullo sarà considerato diverso da nullo :

assertThat(null == null).isTrue(); assertThat("Hello!" == null).isFalse();

Ovviamente, il comportamento degli operatori di uguaglianza può essere limitante. E se volessimo confrontare due oggetti mappati su indirizzi diversi e tuttavia considerarli uguali in base ai loro stati interni? Vedremo come nelle prossime sezioni.

3. Oggetto # è uguale a Metodo

Ora parliamo di un concetto più ampio di uguaglianza con il metodo equals () .

Questo metodo è definito nella classe Object in modo che ogni oggetto Java lo erediti. Per impostazione predefinita, la sua implementazione confronta gli indirizzi di memoria degli oggetti, quindi funziona allo stesso modo dell'operatore == . Tuttavia, possiamo sovrascrivere questo metodo per definire cosa significa uguaglianza per i nostri oggetti.

Per prima cosa, vediamo come si comporta per oggetti esistenti come Integer :

Integer a = new Integer(1); Integer b = new Integer(1); assertThat(a.equals(b)).isTrue();

Il metodo restituisce ancora true quando entrambi gli oggetti sono uguali.

Dobbiamo notare che possiamo passare un oggetto nullo come argomento del metodo, ma ovviamente non come l'oggetto su cui chiamiamo il metodo.

Possiamo usare il metodo equals () con un nostro oggetto. Supponiamo di avere una classe Person :

public class Person { private String firstName; private String lastName; public Person(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } }

Possiamo sovrascrivere il metodo equals () per questa classe in modo da poter confrontare due Persona in base ai loro dettagli interni:

@Override public boolean equals(Object o)  if (this == o) return true; if (o == null 

Per ulteriori informazioni, vedere il nostro articolo su questo argomento.

4. Oggetti # è uguale al metodo statico

Diamo ora un'occhiata al metodo statico Oggetti # uguale . Abbiamo accennato in precedenza che non possiamo usare null come valore del primo oggetto altrimenti verrebbe generata una NullPointerException .

Il metodo equals () della classe helper Objects risolve questi problemi. Prende due argomenti e li confronta, gestendo anche valori nulli .

Confrontiamo nuovamente gli oggetti Persona con:

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();

Come abbiamo detto, il metodo gestisce valori nulli . Pertanto, se entrambi gli argomenti sono nulli , restituirà true e se solo uno di essi è nullo , restituirà false .

Questo può essere davvero utile. Supponiamo di voler aggiungere una data di nascita opzionale alla nostra classe Persona :

public Person(String firstName, String lastName, LocalDate birthDate) { this(firstName, lastName); this.birthDate = birthDate; }

Quindi, dovremmo aggiornare il nostro metodo equals () ma con una gestione nulla . Potremmo farlo aggiungendo questa condizione al nostro metodo equals () :

birthDate == null ? that.birthDate == null : birthDate.equals(that.birthDate);

Tuttavia, se aggiungiamo molti campi nullable alla nostra classe, può diventare davvero complicato. L'utilizzo del metodo Objects # equals nella nostra implementazione equals () è molto più pulito e migliora la leggibilità:

Objects.equals(birthDate, that.birthDate);

5. Interfaccia comparabile

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

In questo articolo, abbiamo esaminato i diversi modi per confrontare gli oggetti in Java. Abbiamo esaminato la differenza tra identità, uguaglianza e ordinamento. Abbiamo anche esaminato le funzioni corrispondenti nelle librerie Apache Commons e Guava.

Come al solito, il codice completo per questo articolo può essere trovato su GitHub.