Comment Comparer les Chaînes en Java

La chaîne est une série de caractères. Elle est un type de données qui est fréquemment utilisé en Java, donc la comparaison des chaînes est l'une des opérations Java les plus utilisées. Cependant, très souvent les dévelopeurs ne peuvent pas faire face à cet opération. Si vous essayez de résoudre ce problème, vous êtes à la bonne place! Dans cet article, nous allons présenter les différents moyens de comparer les chaînes en Java.

1. Comparaison des chaînes avec la Classe de String

Cette méthode propose 5 différents moyens de comparer les chaînes en Java. Nous allons considérer chacun.

1.1. Using “==” Comparison Operator

Attention: L'opérateur “==” ne compare que les références, pas les valeurs. Donc cela est un moyen incorrect de comparer les valeurs de texte. Voyons un exemple:

Exemple

String string1 = "using comparison operator";
String string2 = "using comparison operator";
String string3 = new String("using comparison operator");
  
assertThat(string1 == string2).isTrue();
assertThat(string1 == string3).isFalse();

Comme vous pouvez le voyer, les deux variables pointent au même littérale String, c'est pourquoi la première assertion est vrai, mais la seconde est fausse car string1 est créé avec un littérale et string3 est créé avec le nouvel opérateur, ce qui signifie qu'il font référence aux différents objets.

1.2. Utiiliser equals()

Cette méthode compare deux chaînes sur la base de leur contenu. Cela est comparaison par caractère, qui ignore l'adresse. Si les deux chaînes ont la même longueur et les caractères sont dans le même ordre, cette méthode les considère comme égales et renvoie false. Elle renvoie false si les caractères ne se correspondent pas.

La classe strings propose deux méthode

  • public boolean equals(Object another) compare cette chaîne avec l'objet spécifié.
  • public boolean equalsIgnoreCase(String another) compare cette chaîne avec une autre chaîne, en ignorant la casse.

Syntaxe:

str1.equals(str2);

Maintenant voyons quelques exemples:

Exemple

String string1 = "comparing strings";
String string2 = "comparing strings";
         
String string3 = "comparing STRINGS";
String string4 = new String("comparing strings");
 
assertThat(string1.equals(string2)).isTrue();
assertThat(string1.equals(string4)).isTrue();
 
assertThat(string1.equals(null)).isFalse();
assertThat(string1.equals(string3)).isFalse();

Dans cet exemple, les variables string1, string2, et string4 sont égales car elles ont la même casse et la même valeur indépendamment de leur adresse.

Pour string3, la méthode renvoie false, car elle est sensible à la casse.

De plus, si l'une des deux chaînes est nulle, la méthode renvoie false.

Maintenant, voyons un autre exemple pour veiller que vous avez compris.

Exemple

public class CompareStrings {

    public static void main(String[] args) {

        String style = new String("Bold");
        String style2 = new String("Bold");

        if(style.equals(style2))
            System.out.println("Equal");
        else
            System.out.println("Not Equal");
    }
}

Ici le résultat sera “Equal”.

1.3. Utiliser equalsIgnoreCase()

Comme mentionné au-dessus, il existe également une autre méthode, qui renvoie une valeur booléene. Cette méthode ignore la casse des caractères lors la comparaison des chaînes.

Syntaxe:

str2.equalsIgnoreCase(str1);

Exemple

String string1 = "using equals ignore case";
String string2 = "USING EQUALS IGNORE CASE";
 
assertThat(string1.equalsIgnoreCase(string2)).isTrue();

1.4. Utiliser compareTo()

Cette méthode compare les caractères de deux chaînes lexicographiquement selon un dictionnaire ou un ordre naturel. Elle renvoie une valeur entière qui décrit si la première chaîe est inférieure, égale ou supérieure à la deuxième chaîne.

Imaginons que string1 et string2 sont deux variables. Il y a trois scénarios possibles:

  • string1 == string2 :0
  • string1 > string2 :positive value
  • string1 < string2 :negative value

Syntaxe:

int str1.compareTo(String str2)

Il est le grand temps que nous jetions un coup d'œil à un exemple:

Exemple

String author = "author";
String book = "book";
String duplicateBook = "book";
 
assertThat(author.compareTo(book))
  .isEqualTo(-1);
assertThat(book.compareTo(author))
  .isEqualTo(1);
assertThat(duplicateBook.compareTo(book))
  .isEqualTo(0);

1.5. Utiliser compareToIgnoreCase()

Cela est la même méthode que la précédente. La seule différence est que cette méthode ignore la casse.

Exemple

String author = "Author";
String book = "book";
String duplicateBook = "BOOK";
 
assertThat(author.compareToIgnoreCase(book))
  .isEqualTo(-1);
assertThat(book.compareToIgnoreCase(author))
  .isEqualTo(1);
assertThat(duplicateBook.compareToIgnoreCase(book))
  .isEqualTo(0);

2. Comparaison des chaînes avec la classe Objects

Une classe d'utilité Objects contient une méthode equals(). Elle peut également être utile pour comparer deux chaînes.

Cette méthode premièrement compare les deux chaînnes selon leur adresse, et si ils sont les mêmes, elle renvoie true. Si les deux arguments sont nulles, elle renvoie true, mais si l'un est nulle, elle renvoie false. C'est une méthode sensible à la casse car elle appelle la méthode equals() de la classe String en manière indépendante.

Essayons un exemple.

Exemple

String string1 = "using objects equals";
String string2 = "using objects equals";
String string3 = new String("using objects equals");
 
assertThat(Objects.equals(string1, string2)).isTrue();
assertThat(Objects.equals(string1, string3)).isTrue();
 
assertThat(Objects.equals(null, null)).isTrue();
assertThat(Objects.equals(null, string1)).isFalse();

3. Comparaison des chaînes avec Apache Commons

La bibliothèque Apache Commons contient une classe d'utilitépour les opérations liées à la chaîne, qui est appelé String utils et contient des méthodes utiles pour la comparaison des chaînes. Regardons-les!

3.1. Utiliser equals() et equalsIgnoreCase()

Nous avons déjà présentée la méthode equals() de la classe String et nous avons découvert qu'elle ne traite pas des valeurs nulles. Au contraire, la méthode equals() de la classe StringUtils accepte également des valeurs nulles. Donc, nous pouvons dire que cela est la version actualisée de celle qui appartient à la classe String.

Exemple

assertThat(StringUtils.equals(null, null))
  .isTrue();
assertThat(StringUtils.equals(null, "equals method"))
  .isFalse();
assertThat(StringUtils.equals("equals method", "equals method"))
  .isTrue();
assertThat(StringUtils.equals("equals method", "EQUALS METHOD"))
  .isFalse();

La méthode equalsIgnoreCase() de StringUtils renvoie une valeur booléene. Cela fonctionne également à equals(), mais elle ignore la casse des caractères en chaîne.

Exemple

assertThat(StringUtils.equalsIgnoreCase("equals method", "equals method"))
  .isTrue();
assertThat(StringUtils.equalsIgnoreCase("equals method", "EQUALS METHOD"))
  .isTrue();

3.2. Utiliser equalsAny() et equalsAnyIgnoreCase()

Le premier argument de la méthode equalsAny() est une classe et la deuxième est un type multi-args CharSequence. Cette méthode va renvoyer true si l'une des autres chaînes données correspondra avec la case de la première chaîne sensiblement. Sinon, elle renvoyere false.

Maintenant voyons l'exemple suivant.

Exemple

assertThat(StringUtils.equalsAny(null, null, null))
  .isTrue();
assertThat(StringUtils.equalsAny("equals any", "equals any", "any"))
  .isTrue();
assertThat(StringUtils.equalsAny("equals any", null, "equals any"))
  .isTrue();
assertThat(StringUtils.equalsAny(null, "equals", "any"))
  .isFalse();
assertThat(StringUtils.equalsAny("equals any", "EQUALS ANY", "ANY"))
  .isFalse();

La méthode equalsAnyIgnoreCase() est la même que la précédente, mais en plus cette méthode ignore la case.

Exemple

assertThat(StringUtils.equalsAnyIgnoreCase("ignore case", "IGNORE CASE", "any")).isTrue();

3.3. Utiliser compare() et compareIgnoreCase()

Vous connaissez déjà la méthode compareTo() de la classe String. La méthode compare() de la classe StringUtils est la version sans risque de nulle de la méthode précédente, comme elle traite des valeurs nulles en les considérant comme moins qu'une valeur non-nulle. Deux valeurs nulles sont considérées comme égales.

Cette méthode est utilisée pour trier une liste des chaînes avec des entrées nulles.

Exemple

assertThat(StringUtils.compare(null, null))
  .isEqualTo(0);
assertThat(StringUtils.compare(null, "abc"))
  .isEqualTo(-1);
assertThat(StringUtils.compare("abc", "bbc"))
  .isEqualTo(-1);
assertThat(StringUtils.compare("bbc", "abc"))
  .isEqualTo(1);

La méthode compareIgnoreCase() est la même, mais elle ignore la case aussi.

Exemple

assertThat(StringUtils.compareIgnoreCase("Abc", "bbc"))
  .isEqualTo(-1);
assertThat(StringUtils.compareIgnoreCase("bbc", "ABC"))
  .isEqualTo(1);
assertThat(StringUtils.compareIgnoreCase("abc", "ABC"))
  .isEqualTo(0);

Ces sont les différents moyens de comparer les chaînes en Java. Nous espérons que vous l'avez trouvé utile.

Trouvez-vous cela utile?

Articles Associées