Differenza tra equals() ed ==

DOMANDA:

Che differenza c'è tra il metodo equals() e ==?

RISPOSTA:

Utilizzare il metodo equals(Object o) ereditato da Object() o utilizzare l'operatore di confronto == è estremamente differente. 

METODO equals()

Utilizzando questo metodo stiamo confrontando due oggetti secondo dei criteri di uguaglianza di contenuto, cioè potremmo confrontare una persona con un'altra persona, un animale con un altro animale e così via. Il metodo equals() permette infatti, con opportune personalizzazioni, di selezionare quali sono i criteri di confronto. Così potremo decidere se una persona è uguale ad un'altra se hanno nome e cognome uguali, oppure nome, cognome e data di nascita, ecc... ecc...

OPERATORE ==

Questo operatore di confronto valuta l'uguaglianza sostanziale, ovvero se l'oggetto, il riferimento o il tipo di dato primitivo a sinistra è effettivamente lo stesso di quello a destra. Quindi risulterà vero soltanto quando i riferimenti di memoria coincideranno.

Vediamo la differenza con un esempio pratico in Java usando una classe Coordinate che ha come attributi soltanto i due interi x e y:

Classe Coordinate:

package equals;

public class Coordinate {

  private int x;
  private int y;

  public Coordinate(int x, int y){
    this.x = x;
    this.y = y;
  }

  public int getX() {
    return x;
  }

  public int getY() {
    return y;
  }

  @Override
  public boolean equals(Object coordinate){
    Coordinate c = (Coordinate) coordinate;
    return (this.x == c.getX()) && (this.y == c.getY()); // restituisco vero solo se sia la x che la y coincidono
  }
}

Classe di Test:

package equals;

public class TestUguaglianza {
  public static void main(String[] args) {

    Coordinate c1 = new Coordinate(13, 15);
    Coordinate c2 = new Coordinate(16, 17);
    Coordinate c3 = new Coordinate(13, 15);
    Coordinate c4 = c1;

    System.out.println("CONFRONTO 1: c1(13,15) - c2(16,17)");
    System.out.println("c1 == c2? " + (c1 == c2));
    System.out.println("c1.equals(c2)? " + c1.equals(c2));
    System.out.println();

    System.out.println("CONFRONTO 2: c1(13,15) - c3(13,15)");
    System.out.println("c1 == c3? " + (c1 == c3));
    System.out.println("c1.equals(c3)? " + c1.equals(c3));
    System.out.println();

    System.out.println("CONFRONTO 3: c4 -> c1(13,15)");
    System.out.println("c1 == c4? " + (c1 == c4));
    System.out.println("c1.equals(c4)? " + c1.equals(c4));
  }
}

Infine l'output:

CONFRONTO 1: c1(13,15) - c2(16,17)
c1 == c2? false
c1.equals(c2)? false

CONFRONTO 2: c1(13,15) - c3(13,15)
c1 == c3? false
c1.equals(c3)? true

CONFRONTO 3: c4 -> c1(13,15)
c1 == c4? true
c1.equals(c4)? true

Commentiamo brevemente i risultati associando un'immagine esplicativa:

CONFRONTO 1 - c1 == c2 è false perché ho due oggetti che risiedono in locazioni di memoria differenti. Il confronto con equals() è altrettanto falso perché il test dei contenuti tra la x e la y è effettivamente diverso.

CONFRONTO 1: c1 == c2 FALSE - c1.equals(c2) FALSE

CONFRONTO 2 - c1 == c3 è false nonostante i valori delle coordinate siano uguali. Questo perché, come già detto, == confronta i riferimenti di memoria che risultano, quindi, differenti. Il secondo invece, dato che confronta i valori delle coordinate x e y, restituisce true.

CONFRONTO 2: c1 == c3 FALSE - c1.equals(c3) TRUE

CONFRONTO 3 - In questo caso abbiamo entrambi i confronti true perché il riferimento in memoria è lo stesso (c4 punta alla locazione di memoria c1) e di conseguenza anche i valori confrontati sono uguali.

CONFRONTO 3: c1 == c4 TRUE - c1.equals(c4) TRUE