Comment la comparaison des objets est-elle effectuée…

En Java, la comparaison d'objets se fait de plusieurs manières, en fonction de ce qui doit être comparé : références d'objets ou contenu des objets.

Comparaison de références :

Opérateur == : Vérifie si deux références pointent vers le même objet en mémoire.

Object obj1 = new Object();
Object obj2 = new Object();
boolean areSameReference = (obj1 == obj2); // false, objets différents
Object obj3 = obj1;
boolean areStillSameReference = (obj1 == obj3); // true, références au même objet

Comparaison de contenu :
- Méthode equals() : Cette méthode est définie dans la classe Object et compare par défaut les références. Cependant, les classes peuvent redéfinir cette méthode pour implémenter une logique de comparaison par contenu. Par exemple, String, Integer, collections (ArrayList, HashMap) redéfinissent equals pour comparer les valeurs ou éléments.
```
String str1 = new String("hello");
String str2 = new String("hello");
boolean areEqualContent = str1.equals(str2); // true, contenu identique
boolean areSameReferenceString = (str1 == str2); // false, objets String différents

Integer int1 = 10;
Integer int2 = 10;
boolean areEqualIntegers = int1.equals(int2); // true
boolean areSameReferenceInteger = (int1 == int2); // peut être true ou false selon le cache de Integer, mais il est préférable d'utiliser equals
```
- En redéfinissant la méthode equals(), il faut également redéfinir hashCode() pour respecter le contrat : si obj1.equals(obj2) retourne true, alors obj1.hashCode() doit être égal à obj2.hashCode(). La règle inverse ne s'applique pas : des hashcodes identiques ne garantissent pas l'égalité selon equals().
Comparaison avec compareTo() ou des comparateurs :
- Interface Comparable : Définit la méthode compareTo(T other), qui permet aux objets de sa classe de se comparer avec d'autres objets de la même classe. Retourne une valeur négative, zéro ou positive, indiquant si l'objet courant est inférieur, égal ou supérieur à l'autre.
```
public class MyObject implements Comparable<MyObject> {
    private int value;

    //... constructeur et getters

    @Override
    public int compareTo(MyObject other) {
        return Integer.compare(this.value, other.value);
    }
}
```
- Interface Comparator : Permet de définir une logique de comparaison personnalisée pour n'importe quels objets, même s'ils n'implémentent pas Comparable. Utile lorsque différents critères de tri ou de comparaison sont nécessaires, ou lorsque la classe d'origine ne peut être modifiée.
```
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());
    }
}
```

Le choix de la méthode de comparaison dépend de la tâche spécifique : == pour vérifier l'identité des objets, equals() pour vérifier l'égalité du contenu, et Comparable/Comparator pour définir l'ordre ou effectuer des comparaisons complexes.

Comment la comparaison des objets est-elle effectuée en Java?