Programmazione.it :: Semplificare la realizzazione dell'operatore equals() di Java

Semplificare la realizzazione dell'operatore equals() di Java

Scritto da Francesco Carotenuto il 28-06-2011 ore 08:45

La realizzazione di un bean con molti campi può diventare molto tediosa, se dobbiamo utilizzare l'operatore equals(...) preposto a verificare se un'istanza di una classe sia uguale o meno a un'altra istanza della stessa classe.

Per realizzare tale operatore si procede facendo l'override del metodo boolean equals(Object obj), definito all'interno di Object. Per cui se abbiamo un bean come Address con i seguenti campi:

public class Address 
{
	private Integer houseNumber;
	private String street;
	private String city;
	private String stateOrProvince;
	private String country;
...

l'implementazione dell equals(...) sarà molto simile alla seguente:

...
@Override
	public boolean equals(Object obj) 
	{
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
 
		Address other = (Address) obj;
 
		if (city == null) 
		{
			if (other.city != null)
				return false;
		} 
		else if (!city.equals(other.city))
			return false;
 
		if (country == null) 
		{
			if (other.country != null)
				return false;
		} 
		else if (!country.equals(other.country))
			return false;
 
		if (houseNumber == null) 
		{
			if (other.houseNumber != null)
				return false;
		} 
		else if (!houseNumber.equals(other.houseNumber))
			return false;
 
		if (stateOrProvince == null) 
		{
			if (other.stateOrProvince != null)
				return false;
		} 
		else if (!stateOrProvince.equals(other.stateOrProvince))
			return false;
 
		if (street == null) 
		{
			if (other.street != null)
				return false;
		} 
		else if (!street.equals(other.street))
			return false;
 
		return true;
	}
...

Tale implementazione, oltre che essere molto dispendiosa da realizzare, è anche molto poco leggibile, per cui si può pensare di semplificare lo stesso equals() nel modo seguente:

...
@Override
	public boolean equals(Object obj) 
	{
		boolean result;
 
		if (this == obj)
			result = true;
		else if (obj!=null && getClass() == obj.getClass())
		{
			Address other = (Address) obj;
 
			Object[] fields = 
				{houseNumber, street, city, stateOrProvince, country};
 
			Object[] otherFields = 
						{other.houseNumber, other.street, other.city, 
						other.stateOrProvince, other.country};
 
			result = Arrays.equals(fields, otherFields);
		}
		else result = false;
 
		return result;
	}
...

In pratica il confronto tra i vari campi presenti nelle due istanze viene eseguito in due fasi: nella prima si costruiscono due array fields e otherFields, che conterranno tutti i valori dei campi delle due istanze da confrontare; nella seconda fase, si applicherà, sui due array realizzati, la funzione Arrays.equals(...), che confronta gli elementi dei due array, a uno a uno, restituendone il risultato.

Possiamo notare che il confronto di due istanze della stessa classe bean, porta ad avere a che fare con due array delle stesse dimensioni; è di conseguenza possibile utilizzare, allo scopo di migliorare le perfomance, la funzione Arrays.deepEquals(...).