# Comparer des strings avec Java compareTo() et equals()

Il existe trois options pratiques pour comparer des chaînes de caractères (*strings*) : Java `compareTo()`, `Java equals()` et l’opérateur `==`. Découvrez ces trois méthodes dans notre article.

## Comment comparer des chaînes de caractères en Java ?

Alors que l’on peut facilement comparer les [types de données primitifs en Java](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/java-primitives/) avec l’[opérateur Java](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/operateur-java/) `==` correspondant, c’est un peu plus compliqué dans le cas des [chaînes de caractères Java](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/java-strings/). Vous pouvez utiliser l’opérateur, mais il ne comparera pas le contenu des deux chaînes, **seulement la référence à l’objet correspondant**. Cela peut être suffisant dans certains cas, mais dans d’autres, une méthode différente est nécessaire pour obtenir le résultat souhaité. Heureusement, ce [langage de programmation Web](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/langages-de-programmation-web/) offre plusieurs possibilités. En voici trois qui sont relativement courantes :

- Java `equals()`
- Java `compareTo()` pour les strings
- Opérateur Java `==`

## La méthode Java `equals()`

La méthode la plus simple et la plus pratique pour comparer le contenu de deux chaînes de caractères est la méthode appelée « equals() » en Java. Elle **confronte effectivement les deux valeurs**. Si elles correspondent exactement, la méthode renvoie `true` (vrai) comme confirmation. Si elles diffèrent d’une quelconque manière, le résultat sera `false` (faux). Voici la syntaxe de cette méthode :

```java
public boolean equals(Objet autreObjet)
```

Afin de mieux comprendre le fonctionnement de la méthode, prenons un exemple concret. Pour cela, nous créons trois chaînes de caractères et comparons la première de ces chaînes avec les deux autres. Voici à quoi cela ressemble dans la pratique :

```java
public class Main {
    public static void main(String[] args) {
        String chaine1 = "Ceci est une chaîne";
        String chaine2 = "Ceci est une chaîne";
        String chaine3 = "Ceci est une toute autre chaîne";
        System.out.println(chaine1.equals(chaine2));
        System.out.println(chaine1.equals(chaine3));
    }
}
```

Si nous affichons maintenant ce code avec la [commande Java](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/les-commandes-java/) `System.out.println`, nous obtenons ceci :

```java
true
false
```

`chaine1`et `chaine2`sont identiques, mais `chaine3`est différente des deux autres. Dans cet exemple, la différence est visible à l’œil nu. Cependant, dans d’autres cas de figure, il peut y avoir des chaînes qui se ressemblent à première vue, mais qui diffèrent par un petit détail. Java `equals()` est une très bonne méthode pour éviter les erreurs à ce niveau.

## Java `compareTo()` pour les strings

La deuxième méthode est un peu plus complexe, mais fonctionne aussi de manière fiable. Java `compareTo()` compare les strings **lexicographiquement selon la valeur Unicode de chaque caractère** dans une chaîne. Les différents caractères sont comparés et alignés. Si deux chaînes correspondent, la méthode renvoie 0 comme réponse. Si la première chaîne est plus courte que la deuxième, une valeur négative est émise. En revanche, si elle est plus longue, la sortie est une valeur positive. Voici la syntaxe de cette méthode :

```java
public int compareTo(Chaine autreChaine)
```

Voici à nouveau un exemple concret pour mettre la syntaxe en pratique. Nous créons à nouveau trois chaînes de caractères et comparons la première avec les deux autres.

```java
public class Main {
    public static void main(String[] args) {
        String chaine1 = "Ceci est une chaîne";
        String chaine2 = "Ceci est une chaîne";
        String chaine3 = "Ceci est une toute autre chaîne";
        System.out.println(chaine1.compareTo(chaine2));
        System.out.println(chaine1.compareTo(chaine3));
    }
}
```

Si nous affichons maintenant ce code avec `System.out.println`, nous obtenons ceci :

```java
0
-12
```

Si vous voulez utiliser Java `compareTo()` pour des strings, mais en ignorant les majuscules et les minuscules, utilisez la méthode adaptée `compareToIgnoreCase()`. Celle-ci fonctionne comme suit :

```java
public class Main {
    public static void main(String[] args) {
        String chaine1 = "Ceci est une chaîne";
        String chaine2 = "Ceci est une chaîne";
        String chaine3 = "CECI EST UNE CHAÎNE";
        System.out.println(chaine1.compareToIgnoreCase(chaine2));
        System.out.println(chaine1.compareToIgnoreCase(chaine3));
    }
}
```

La sortie change en conséquence :

```java
0
0
```

## L’opérateur Java `==`

Comme mentionné plus tôt, vous pouvez en principe aussi utiliser l’opérateur `==` pour comparer deux strings. Il comparera les références et non les valeurs proprement dites. Voici un exemple :

```java
public class Main {
    public static void main(String[] args) {
        String chaine1 = "Ceci est une chaîne";
        String chaine2 = "Ceci est une chaîne";
        String chaine3 = new String("Ceci est une chaîne");
        System.out.println(chaine1 == chaine2);
        System.out.println(chaine1 == chaine3);
    
}
```

Comme `chaine1` et `chaine2` se réfèrent à la même instance, la sortie est « true ». Par contre, `chaine3` se réfère à une **autre instance**. Le résultat est donc « false », bien que la valeur ou le texte à l’intérieur des chaînes soit identique.

```java
true
false
```


This is a markdown version of: [https://www.ionos.fr/digitalguide/sites-internet/developpement-web/comparaison-de-strings-avec-java-compareto-et-equals/](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/comparaison-de-strings-avec-java-compareto-et-equals/) for AI/LLM consumption.