Diferencias entre método equals() y operador ==

Si comparamos tipos primitivos con los operadores == o != el resultado es el esperado. Sin embargo, si comparamos objetos con estos dos operadores el resultado puede no ser el esperado. Tenemos el ejemplo siguiente:

 public class Equivalencia {
   public static void main(String[] args) {
     Integer n1 = new Integer(47);
     Integer n2 = new Integer(47);
 
     System.out.println("n1==n2: "+n1 == n2);
     System.out.println("n1!=n2: "+n1 != n2);

     String s1 = new String("Hola");
     String s2 = new String("Hola");

     System.out.println("s1==s2: "+s1 == s2);
     System.out.println("s1!=s2: "+s1 != s2);
   }
} 

Si lo ejecutamos el resultado es:

n1==n2: false
n1!=n2: true
s1==s2: false
s1!=s2: true

Esto se debe a que los operadores == y != comparan referencias, no valores. La referencia de n1 está almacenada en un lugar de la memoria y la de n2 en otra, lo mismo para s1 y s2. Recuerda que cada vez que se crea un objeto con new se le asigna un espacio de memoria en el cúmulo.
Para comparar objetos, no tipos primitivos, tenemos el método equals(), que se puede utilizar siempre, ya que está incluido en la clase java.lang.Object que por defecto heredan todas las clases. Este método compara valores en lugar de referencias, modificamos un poco el ejemplo anterior y utilizamos equals():

 public class Equivalencia2 {
   public static void main(String[] args) {
     Integer n1 = new Integer(47);
     Integer n2 = new Integer(47);
 
     System.out.println("n1.equals(n2): "+n1.equals(n2));

     String s1 = new String("Hola");
     String s2 = new String("Hola");

     System.out.println("s1.equals(s2): "+s1.equals(s2));
   }
} 

El resultado es:

n1.equals(n2): true
s1.equals(s2): true

Sin embargo, fijémonos en los dos siguientes ejemplos:

class Value {
   int i;
}
 
public class Equivalencia3 {
   public static void main(String[] args) {
      Value v1 = new Value();
      Value v2 = new Value();
 
      v1.i = v2.i = 100;
      System.out.println("v1.i=v2.i=100");
      System.out.println("v1.equals(v2): "+v1.equals(v2));
   }
}

El resultado es:

v1.i=v2.i=100
v1.equals(v2): false

El ejemplo siguiente es una variación del Ejercicio 6 del Tema 3. Este ejercicio lo he hecho de varias maneras.

class Dog2{

   String name;
   String says;

   Dog2(String n,String s){
      name=n;
      says=s;
   }

   public String nombre(){
      return name;
   }

   public String says(){
      return says;
   }
}

public class Ejer_6b{

   public static void main(String args[]){
   
      Dog2 dogSpot=new Dog2("Spot","Ruff");
      Dog2 dogScruffy=new Dog2("Scruffy","Wurf");
      Dog2 dogNuevo=new Dog2("Spot","Ruff");
 
      System.out.println("Tengo dos perritos.");
      System.out.println("Uno se llama: "+dogSpot.nombre()+" y ladra diciendo: "+dogSpot.says());
      System.out.println("El otro se llama: "+dogScruffy.nombre()+" y ladra diciendo: "+dogScruffy.says());
      System.out.println("Paco tiene otro perrito y dice que es igual que Spot o que Scruffy, vamos a comprobarlo");   
      System.out.println("Si comparamos a Spot con el perro de Paco utilizando ==: "+(dogSpot==dogNuevo));
      System.out.println("Si comparamos a Scruffy con el perro de Paco utilizando ==: "+(dogScruffy==dogNuevo));

      System.out.println("Si comparamos a Spot con el perro de Paco utilizando equals: "+dogNuevo.equals(dogSpot));
      System.out.println("Si comparamos a Scruffy con el perro de Paco utilizando equals: "+dogNuevo.equals(dogScruffy));
   }
}

Aquí el resultado es:

Tengo dos perritos.
Uno se llama: Spot y ladra diciendo: Ruff
El otro se llama: Scruffy y ladra diciendo: Wurf
Paco tiene otro perrito y dice que es igual que Spot o que 
Scruffy, vamos a comprobarlo
Si comparamos a Spot con el perro de Paco utilizando 
==: false
Si comparamos a Scruffy con el perro de Paco utilizando 
==: false
Si comparamos a Spot con el perro de Paco utilizando 
equals: false
Si comparamos a Scruffy con el perro de Paco utilizando 
equals: false

En las clases creadas por nosotros, el método equals() se comporta comparando referencias, es decir, como el operador ==, por tanto, para comparar dos objetos y comprobar si son iguales o no, deberíamos sobreescribir el método equals() para que tenga este comportamiento, esto lo veremos más adelante.
Vamos a darle otra vuelta de tuerca:

 public class Equivalencia4 {
   public static void main(String[] args) {
     Integer n1 = 47;
     Integer n2 = 47;
     Integer n3 = new Integer(47);
 
     System.out.println("n1==n2: "+(n1 == n2));
     System.out.println("n1!=n2: "+(n1 != n2));
     System.out.println("n1.equals(n2): "+n1.equals(n2));
     System.out.println("n1==n3: "+(n1 == n3));
     System.out.println("n1.equals(n3): "+n1.equals(n3));

     String s1 = "Hola";
     String s2 = "Hola";

     System.out.println("s1==s2: "+(s1 == s2));
     System.out.println("s1!=s2: "+(s1 != s2));
     System.out.println("s1.equals(s2): "+s1.equals(s2));
   }
} 

El resultado es:

n1==n2: true
n1!=n2: false
n1.equals(n2): true
n1==n3: false
n1.equals(n3): true
s1==s2: true
s1!=s2: false
s1.equals(s2): true

Cuando creamos n1 y le damos el valor 47, este valor se guarda en memoria (en la pila). Al crear una nueva variable con valor 47, en lugar de almacenar este valor en memoria, como ya existe, n2 apuntará al valor 47 que está en la pila. Entonces tenemos n1 y n2 apuntando a 47. Lo mismo ocurriría con s1 y s2. Por este motivo, en este ejemplo, las comparaciones tienen el mismo comportamiento para == (referencias) y equals() (valores). Sin embargo, si damos un nuevo valor a n1, n2, s1 o s2, las variables ya no apuntarán al mismo valor y serán de este modo diferentes, tanto para == como para equals(). Si nos fijamos en la variable n3, se crea con new Integer(47), si la comparamos con n1 o n2 el resultado es el siguiente: con == el resultado sería false, ya que al crear un nuevo objeto con new, se le asigna un nuevo espacio de memoria (en el cúmulo), por tanto no apuntaría al valor 47 de la pila, sin embargo, con equals() el comportamiento es el esperado ya que se comparan los valores y estos son iguales. Para recordar dónde se almacena cada tipo de variable, puedes repasar el Tema 2, el apartado Los lugares de almacenamiento.