¿Cómo se comparan los objetos en Java?

En Java, la comparación de objetos se realiza de varias maneras, dependiendo de lo que exactamente se necesita comparar: referencias a objetos o contenido de objetos.

1. Comparación de referencias:

   • Operador ==: Verifica si dos referencias apuntan al mismo objeto en la memoria.

   Object obj1 = new Object();
   Object obj2 = new Object();
   boolean areSameReference = (obj1 == obj2); // false, objetos diferentes
   Object obj3 = obj1;
   boolean areStillSameReference = (obj1 == obj3); // true, referencias al mismo objeto
   

2. Comparación de contenido:

   • Método equals(): Este método está definido en la clase Object y por defecto también compara referencias. Sin embargo, las clases pueden redefinir este método para implementar lógica de comparación por contenido. Por ejemplo, String, Integer, colecciones (como ArrayList, HashMap) redefinen equals para comparar valores o elementos.

   String str1 = new String("hello");
   String str2 = new String("hello");
   boolean areEqualContent = str1.equals(str2); // true, contenido igual
   boolean areSameReferenceString = (str1 == str2); // false, objetos String diferentes
   
   Integer int1 = 10;
   Integer int2 = 10;
   boolean areEqualIntegers = int1.equals(int2); // true
   boolean areSameReferenceInteger = (int1 == int2); // puede ser true o false dependiendo del caché de Integer, pero es mejor usar equals
   

   • Al redefinir el método equals(), también es obligatorio redefinir hashCode() para cumplir con el contrato: Si obj1.equals(obj2) devuelve true, entonces obj1.hashCode() debe ser igual a obj2.hashCode(). La regla inversa no se cumple: códigos hash iguales no garantizan igualdad en equals().

3. Comparación usando compareTo() o comparadores:

   • Interfaz Comparable: Define el método compareTo(T other), que permite a los objetos de su clase compararse con otros objetos de la misma clase. Devuelve un valor negativo, cero o positivo, indicando si el objeto actual es menor, igual o mayor que el otro.

   public class MyObject implements Comparable<MyObject> {
       private int value;
   
       //... constructor y getters
   
       @Override
       public int compareTo(MyObject other) {
           return Integer.compare(this.value, other.value);
       }
   }
   

   • Interfaz Comparator: Permite definir lógica de comparación personalizada para cualquier objeto, incluso si no implementan Comparable. Es útil cuando se necesita diferentes criterios de ordenamiento o comparación, o cuando no se puede modificar la clase original.

   import java.util.Comparator;
   
   public class MyObjectValueComparator implements Comparator<MyObject> {
       @Override
       public int compare(MyObject obj1, MyObject obj2) {
           return Integer.compare(obj1.getValue(), obj2.getValue());
       }
   }
   

La elección del método de comparación depende de la tarea específica: == para verificar identidad de objetos, equals() para verificar igualdad de contenido, y Comparable/Comparator para definir orden o realizar comparaciones complejas.