How are objects compared in Java?

In Java, object comparison is performed in several ways, depending on what exactly needs to be compared: object references or object contents.

1. Reference comparison:

   • Operator ==: Checks whether two references point to the same object in memory.

   Object obj1 = new Object();
   Object obj2 = new Object();
   boolean areSameReference = (obj1 == obj2); // false, different objects
   Object obj3 = obj1;
   boolean areStillSameReference = (obj1 == obj3); // true, references to the same object
   

2. Content comparison:

   • Method equals(): This method is defined in the Object class and by default also compares references. However, classes can override this method to implement content-based comparison logic. For example, String, Integer, collections (such as ArrayList, HashMap) override equals to compare values or elements.

   String str1 = new String("hello");
   String str2 = new String("hello");
   boolean areEqualContent = str1.equals(str2); // true, same content
   boolean areSameReferenceString = (str1 == str2); // false, different String objects
   
   Integer int1 = 10;
   Integer int2 = 10;
   boolean areEqualIntegers = int1.equals(int2); // true
   boolean areSameReferenceInteger = (int1 == int2); // can be true or false depending on Integer caching, but better to use equals
   

   • When overriding equals(), it is also necessary to override hashCode() to maintain the contract: If obj1.equals(obj2) returns true, then obj1.hashCode() must be equal to obj2.hashCode(). The reverse is not true: equal hash codes do not guarantee object equality by equals().

3. Comparison using compareTo() or comparators:

   • Comparable interface: Defines the compareTo(T other) method, which allows objects of its class to compare themselves with other objects of the same class. It returns a negative, zero, or positive value indicating whether the current object is less than, equal to, or greater than the specified object.

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

   • Comparator interface: Allows defining custom comparison logic for any objects, even if they do not implement Comparable. This is useful when different sorting or comparison logic is needed for the same class, or when the original class cannot be modified.

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

The choice of comparison method depends on the specific task: == for identity check, equals() for content equality, and Comparable/Comparator for ordering or complex comparisons.